diff_matcher 2.1.1 → 2.2.0

data/README.md

@@ -105,20 +105,37 @@ puts DiffMatcher::difference([1], [1, 2])
 ```
 
 
-When `expected` can take multiple forms use a `Matcher`
+When `expected` is a `Hash` with optional keys use a `Matcher`.
 
 ``` ruby
-puts DiffMatcher::difference(DiffMatcher::Matcher[Fixnum,Float], "3")
+puts DiffMatcher::difference(
+  DiffMatcher::Matcher.new({:name=>String, :age=>Fixnum}, :optional_keys=>[:age]),
+  {:name=>0}
+)
+{
+  :name=>- String+ 0
+}
+Where, - 1 missing, + 1 additional
+```
+
+
+When `expected` can take multiple forms use some `Matcher`s `||`ed together.
+
+``` ruby
+puts DiffMatcher::difference(DiffMatcher::Matcher.new(Fixnum) || DiffMatcher.new(Float), "3")
 - Float+ "3"
 Where, - 1 missing, + 1 additional
 ```
+(NB. `DiffMatcher::Matcher[Fixnum, Float]` can be used as a shortcut for 
+     `DiffMatcher::Matcher.new(Fixnum) || DiffMatcher.new(Float)`
+)
 
 
-When `actual` is an array of unknown size use an `AllMatcher` to match
+When `actual` is an array of *unknown* size use an `AllMatcher` to match
 against *all* the elements in the array.
 
 ``` ruby
-puts DiffMatcher::difference(DiffMatcher::AllMatcher[Fixnum], [1, 2, "3"])
+puts DiffMatcher::difference(DiffMatcher::AllMatcher.new(Fixnum), [1, 2, "3"])
 [
   : 1,
   : 2,
@@ -128,15 +145,30 @@ 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`.
+
+``` ruby
+puts DiffMatcher::difference(DiffMatcher::AllMatcher.new(Fixnum, :min=>3), [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
 against *all* the elements in the array in any of the forms.
 
 ``` ruby
 puts DiffMatcher::difference(
-  DiffMatcher::AllMatcher[
+  DiffMatcher::AllMatcher.new(
     DiffMatcher::Matcher[Fixnum, Float]
-  ],
+  ),
   [1, 2.00, "3"]
 )
 [
@@ -175,6 +207,8 @@ The items shown in a difference are prefixed as follows:
     match value   =>
     match regexp  => "~ "
     match class   => ": "
+    match matcher => "| "
+    match proc    => ". "
     match proc    => "{ "
 
 
@@ -189,6 +223,8 @@ Using the `:default` colour scheme items shown in a difference are coloured as f
     match value   =>
     match regexp  => green
     match class   => blue
+    match matcher => blue
+    match range   => cyan
     match proc    => cyan
 
 Other colour schemes, eg. `:color_scheme=>:white_background` will use different colour mappings.

data/lib/diff_matcher/difference.rb

@@ -8,13 +8,13 @@ module DiffMatcher
   class Matcher
     attr_reader :expecteds
 
-    def self.[](*expected)
-      new(*expected)
+    def self.[](*expecteds)
+      expecteds.inject(nil) { |obj, e| obj ? obj | new(e) : new(e) }
     end
 
-    def initialize(*expected)
-      @expecteds = [expected].flatten
-      @opts = {}
+    def initialize(expected, opts={})
+      @expecteds = [expected]
+      @expected_opts = {expected => opts}
     end
 
     def |(other)
@@ -22,25 +22,39 @@ module DiffMatcher
       tap { @expecteds += other.expecteds }
     end
 
-    def expected(expected, actual)
-      expected
+    def expected(e, actual)
+      e
+    end
+
+    def expected_opts(e)
+      @expected_opts.fetch(e, {})
     end
 
     def diff(actual, opts={})
-      dif = nil
-      @expecteds.any? { |e|
-        d = DiffMatcher::Difference.new(expected(e, actual), actual, opts)
-        dif = d.matching? ? nil : d.dif
+      difs = []
+      matched = @expecteds.any? { |e|
+        d = DiffMatcher::Difference.new(expected(e, actual), actual, opts.merge(expected_opts(e)))
+        unless d.matching?
+          difs << [ d.dif_count, d.dif ]
+        end
         d.matching?
       }
-      dif
+      unless matched
+        count, dif = difs.sort.last
+        dif
+      end
     end
   end
 
   class NotAnArray < Exception; end
   class AllMatcher < Matcher
-    def expected(expected, actual)
-      [expected]*actual.size
+    def expected(e, actual)
+      opts = expected_opts(e)
+      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
 
     def diff(actual, opts={})
@@ -67,6 +81,7 @@ module DiffMatcher
         :match_regexp  => [GREEN , "~"],
         :match_class   => [BLUE  , ":"],
         :match_matcher => [BLUE  , "|"],
+        :match_range   => [CYAN  , "."],
         :match_proc    => [CYAN  , "{"]
     }
 
@@ -83,6 +98,8 @@ module DiffMatcher
       @quiet             = opts[:quiet]
       @color_enabled     = opts[:color_enabled] || !!opts[:color_scheme]
       @color_scheme      = COLOR_SCHEMES[opts[:color_scheme] || :default]
+      @optional_keys = opts.delete(:optional_keys) || []
+      @dif_count = 0
       @difference = difference(expected, actual)
     end
 
@@ -101,6 +118,7 @@ module DiffMatcher
           unless item_type == :match_value
             color, prefix = @color_scheme[item_type]
             count = msg.scan("#{color}#{prefix}").size
+            @dif_count += count if [:missing, :additional].include? item_type
             "#{color}#{prefix} #{BOLD}#{count} #{item_type}#{RESET}" if count > 0
           end
         }.compact.join(", ")
@@ -110,6 +128,10 @@ module DiffMatcher
       end
     end
 
+    def dif_count
+      @dif_count
+    end
+
     def dif
       @difference
     end
@@ -132,7 +154,7 @@ module DiffMatcher
       @matches_shown ||= lambda {
         ret = []
         unless @quiet
-          ret += [:match_matcher, :match_class, :match_proc, :match_regexp]
+          ret += [:match_matcher, :match_class, :match_range, :match_proc, :match_regexp]
           ret += [:match_value]
         end
         ret
@@ -185,7 +207,7 @@ module DiffMatcher
 
     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)
+        "#{"#{k.inspect}=>" if expected_class == Hash}#{left[k].inspect}" unless right.has_key?(k) || @optional_keys.include?(k)
       }
     end
 
@@ -199,6 +221,7 @@ module DiffMatcher
           d = expected.diff(actual, @opts)
                       [d.nil?                                      , :match_matcher, d]
         when Class  ; [actual.is_a?(expected)                         , :match_class  ]
+        when Range  ; [expected.include?(actual)                      , :match_range  ]
         when Proc   ; [expected.call(actual)                          , :match_proc   ]
         when Regexp ; [actual.is_a?(String) && actual.match(expected) , :match_regexp ]
         else          [actual == expected                             , :match_value  ]

data/lib/diff_matcher/version.rb

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

data/spec/diff_matcher/difference_spec.rb

@@ -9,13 +9,15 @@ def fix_EOF_problem(s)
   # <<-EOF isn't working like its meant to :(
   whitespace = s.split("\n")[-1][/^[ ]+/]
   indentation = whitespace ? whitespace.size : 0
-  s.gsub("\n#{" " * indentation}", "\n").strip
+  s.gsub("\n#{" " * indentation}", "\n").tap { |result|
+    result.strip! if whitespace
+  }
 end
 
 
-shared_examples_for "a matcher" do |expected, expected2, same, different, difference, opts|
+shared_examples_for "an or-ed matcher" do |expected, expected2, same, different, difference, opts|
   opts ||= {}
-  context "with #{opts.size > 0 ? opts_to_s(opts) : "no opts"}" do
+  context "where expected=#{expected.inspect}, expected2=#{expected2.inspect}" do
     describe "diff(#{same.inspect}#{opts_to_s(opts)})" do
       let(:expected ) { expected }
       let(:expected2) { expected }
@@ -32,7 +34,7 @@ shared_examples_for "a matcher" do |expected, expected2, same, different, differ
       let(:opts     ) { opts      }
 
       it { should_not be_nil } unless RUBY_1_9
-      it { should == fix_EOF_problem(difference)+"\n" } if RUBY_1_9
+      it { should == fix_EOF_problem(difference) } if RUBY_1_9
     end
   end
 end
@@ -44,23 +46,24 @@ describe DiffMatcher::Matcher do
     {:name   => String   , :age    => Integer },
     {:name   => "Peter"  , :age    => 21      },
     {:name   => 21       , :age    => 21      },
-    <<-EOF
-    {
-      :name=>\e[31m- \e[1mString\e[0m\e[33m+ \e[1m21\e[0m,
-      :age=>\e[34m: \e[1m21\e[0m
-    }
-    EOF
+    "{\n  :name=>\e[31m- \e[1mString\e[0m\e[33m+ \e[1m21\e[0m,\n  :age=>\e[34m: \e[1m21\e[0m\n}\n"
 
   describe "DiffMatcher::Matcher[expected, expected2]," do
     subject { DiffMatcher::Matcher[expected, expected2].diff(actual) }
 
-    it_behaves_like "a matcher", expected, expected2, same, different, difference
-  end
+    it_behaves_like "an or-ed matcher", expected, expected2, same, different, difference
 
-  describe "DiffMatcher::Matcher[expected] | DiffMatcher::Matcher[expected2])" do
-    subject { (DiffMatcher::Matcher[expected] | DiffMatcher::Matcher[expected2]).diff(actual) }
+    context "when Matchers are or-ed it works the same" do
+      subject { (DiffMatcher::Matcher[expected] | DiffMatcher::Matcher[expected2]).diff(actual) }
+
+      it_behaves_like "an or-ed matcher", expected, expected2, same, different, difference
+    end
 
-    it_behaves_like "a matcher", expected, expected2, same, different, difference
+    context "expecteds are in different order it still uses the closest dif" do
+      subject { DiffMatcher::Matcher[expected2, expected].diff(actual) }
+
+      it_behaves_like "an or-ed matcher", expected2, expected, same, different, difference
+    end
   end
 end
 
@@ -119,6 +122,36 @@ shared_examples_for "a diff matcher" do |expected, same, different, difference,
   end
 end
 
+describe "DiffMatcher::Matcher[expected].diff(actual, opts)" do
+  subject { DiffMatcher::Matcher[expected].diff(actual, opts) }
+
+  describe "when expected is an instance," do
+    context "of Fixnum," do
+      expected, same, different =
+        1,
+        1,
+        2
+
+      it_behaves_like "a diff matcher", expected, same, different,
+        "\e[31m- \e[1m1\e[0m\e[33m+ \e[1m2\e[0m", {}
+    end
+  end
+
+  describe "when expected is an instance," do
+    context "of Hash, with optional keys" do
+      expected, same, different =
+        {:a=>1, :b=>Fixnum},
+        {:a=>1},
+        {:a=>2}
+
+      it_behaves_like "a diff matcher", expected, same, different,
+        "{\n  :a=>\e[31m- \e[1m1\e[0m\e[33m+ \e[1m2\e[0m\n}\n",
+        {:optional_keys=>[:b]}
+    end
+  end
+end
+
+
 describe "DiffMatcher::difference(expected, actual, opts)" do
   subject { DiffMatcher::difference(expected, actual, opts) }
 
@@ -247,6 +280,19 @@ describe "DiffMatcher::difference(expected, actual, opts)" do
       end
     end
 
+    context "of Range," do
+      expected, same, different =
+        (1..3),
+        2,
+        4
+
+      it_behaves_like "a diff matcher", expected, same, different,
+        <<-EOF
+        - 1..3+ 4
+        Where, - 1 missing, + 1 additional
+        EOF
+    end
+
     context "of Hash," do
       expected, same, different =
         { "a"=>1 },
@@ -396,6 +442,40 @@ describe "DiffMatcher::difference(expected, actual, opts)" do
         EOF
 
       end
+
+      context "with a min restriction" do
+        expected, same, different =
+          DiffMatcher::AllMatcher.new(String, :min=>3),
+          %w(ay be ci),
+          %w(ay be)
+
+        it_behaves_like "a diff matcher", expected, same, different,
+          <<-EOF
+          [
+            : "ay",
+            : "be",
+          - String
+          ]
+          Where, - 1 missing, : 2 match_class
+          EOF
+      end
+
+      context "with a max restriction" do
+        expected, same, different =
+          DiffMatcher::AllMatcher.new(String, :max=>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
@@ -450,11 +530,11 @@ describe "DiffMatcher::difference(expected, actual, opts)" do
 
   context "when expected has multiple items," do
     expected, same, different =
-      [ 1,  2, /\d/, Fixnum, lambda { |x| (4..6).include? x } ],
-      [ 1,  2, "3" , 4     , 5                                ],
-      [ 0,  2, "3" , 4     , 5                                ]
+      [ 1,  2, /\d/, Fixnum, 4..6 , lambda { |x| x % 6 == 0 } ],
+      [ 1,  2, "3" , 4     , 5    , 6                         ],
+      [ 0,  2, "3" , 4     , 5    , 6                         ]
 
-    describe "it shows regex, class, proc matches and matches" do
+    describe "it shows regex, class, range, proc matches and matches" do
       it_behaves_like "a diff matcher", expected, same, different,
         <<-EOF
         [
@@ -462,9 +542,10 @@ describe "DiffMatcher::difference(expected, actual, opts)" do
           2,
           ~ "(3)",
           : 4,
-          { 5
+          . 5,
+          { 6
         ]
-        Where, - 1 missing, + 1 additional, ~ 1 match_regexp, : 1 match_class, { 1 match_proc
+        Where, - 1 missing, + 1 additional, ~ 1 match_regexp, : 1 match_class, . 1 match_range, { 1 match_proc
         EOF
     end
 
@@ -486,9 +567,10 @@ describe "DiffMatcher::difference(expected, actual, opts)" do
           2,
           ~ "(3)",
           : 4,
-          { 5
+          . 5,
+          { 6
         ]
-        Where, - 1 missing, + 1 additional, ~ 1 match_regexp, : 1 match_class, { 1 match_proc
+        Where, - 1 missing, + 1 additional, ~ 1 match_regexp, : 1 match_class, . 1 match_range, { 1 match_proc
         EOF
     end
 
@@ -500,9 +582,10 @@ describe "DiffMatcher::difference(expected, actual, opts)" do
         \e[0m  2,
         \e[0m  \e[32m~ \e[0m"\e[32m(\e[1m3\e[0m\e[32m)\e[0m"\e[0m,
         \e[0m  \e[34m: \e[1m4\e[0m,
-        \e[0m  \e[36m{ \e[1m5\e[0m
+        \e[0m  \e[36m. \e[1m5\e[0m,
+        \e[0m  \e[36m{ \e[1m6\e[0m
         \e[0m]
-        Where, \e[31m- \e[1m1 missing\e[0m, \e[33m+ \e[1m1 additional\e[0m, \e[32m~ \e[1m1 match_regexp\e[0m, \e[34m: \e[1m1 match_class\e[0m, \e[36m{ \e[1m1 match_proc\e[0m
+        Where, \e[31m- \e[1m1 missing\e[0m, \e[33m+ \e[1m1 additional\e[0m, \e[32m~ \e[1m1 match_regexp\e[0m, \e[34m: \e[1m1 match_class\e[0m, \e[36m. \e[1m1 match_range\e[0m, \e[36m{ \e[1m1 match_proc\e[0m
         EOF
 
       context "on a white background" do
@@ -513,9 +596,10 @@ describe "DiffMatcher::difference(expected, actual, opts)" do
           \e[0m  2,
           \e[0m  \e[32m~ \e[0m"\e[32m(\e[1m3\e[0m\e[32m)\e[0m"\e[0m,
           \e[0m  \e[34m: \e[1m4\e[0m,
-          \e[0m  \e[36m{ \e[1m5\e[0m
+          \e[0m  \e[36m. \e[1m5\e[0m,
+          \e[0m  \e[36m{ \e[1m6\e[0m
           \e[0m]
-          Where, \e[31m- \e[1m1 missing\e[0m, \e[35m+ \e[1m1 additional\e[0m, \e[32m~ \e[1m1 match_regexp\e[0m, \e[34m: \e[1m1 match_class\e[0m, \e[36m{ \e[1m1 match_proc\e[0m
+          Where, \e[31m- \e[1m1 missing\e[0m, \e[35m+ \e[1m1 additional\e[0m, \e[32m~ \e[1m1 match_regexp\e[0m, \e[34m: \e[1m1 match_class\e[0m, \e[36m. \e[1m1 match_range\e[0m, \e[36m{ \e[1m1 match_proc\e[0m
           EOF
       end
     end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: diff_matcher
 version: !ruby/object:Gem::Version 
-  hash: 9
+  hash: 7
   prerelease: 
   segments: 
   - 2
-  - 1
-  - 1
-  version: 2.1.1
+  - 2
+  - 0
+  version: 2.2.0
 platform: ruby
 authors: 
 - Playup
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-01-13 00:00:00 +11:00
+date: 2012-01-19 00:00:00 +11:00
 default_executable: 
 dependencies: []