diff_matcher 2.0.1 → 2.1.0

data/.rspec

@@ -0,0 +1 @@
+--color

data/README.md

@@ -20,11 +20,11 @@ actual == expected     # when expected is anything else
 Example:
 
 ``` ruby
-    puts DiffMatcher::difference(
-      { :a=>{ :a1=>11          }, :b=>[ 21, 22 ], :c=>/\d/, :d=>Fixnum, :e=>lambda { |x| (4..6).include? x } },
-      { :a=>{ :a1=>10, :a2=>12 }, :b=>[ 21     ], :c=>'3' , :d=>4     , :e=>5                                },
-      :color_scheme=>:white_background
-    )
+puts DiffMatcher::difference(
+  { :a=>{ :a1=>11          }, :b=>[ 21, 22 ], :c=>/\d/, :d=>Fixnum, :e=>lambda { |x| (4..6).include? x } },
+  { :a=>{ :a1=>10, :a2=>12 }, :b=>[ 21     ], :c=>'3' , :d=>4     , :e=>5                                },
+  :color_scheme=>:white_background
+)
 ```
 
 ![example output](https://raw.github.com/playup/diff_matcher/master/doc/diff_matcher.gif)
@@ -87,6 +87,7 @@ When `actual` is missing one of the `expected` values
 ``` ruby
 puts DiffMatcher::difference([1, 2], [1])
 # => [
+# =>   1
 # => - 2
 # => ]
 # => Where, - 1 missing
@@ -97,11 +98,55 @@ When `actual` has additional values to the `expected`
 ``` ruby
 puts DiffMatcher::difference([1], [1, 2])
 # => [
+# =>   1
 # => + 2
 # => ]
 # => Where, + 1 additional
 ```
 
+
+When `expected` can take multiple forms use a `Matcher`
+
+``` ruby
+puts DiffMatcher::difference(DiffMatcher::Matcher[Fixnum,Float], "3")
+- Float+ "3"
+Where, - 1 missing, + 1 additional
+```
+
+
+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"])
+[
+  : 1,
+  : 2,
+  - Fixnum+ "3"
+]
+Where, - 1 missing, + 1 additional, : 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::Matcher[Fixnum, Float]
+  ],
+  [1, 2.00, "3"]
+)
+[
+  | 1,
+  | 2.0,
+  - Float+ "3"
+]
+Where, - 1 missing, + 1 additional, | 2 match_matcher
+```
+
 ### Options
 
 `:ignore_additional=>true` will match even if `actual` has additional items
@@ -182,6 +227,74 @@ 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.
 
 
+Use with rspec
+---
+To use with rspec create the following custom matcher:
+
+``` ruby
+require 'diff_matcher'
+
+module RSpec
+  module Matchers
+    class BeMatching
+      include BaseMatcher
+
+      def initialize(expected, opts)
+        @expected = expected
+        @opts = opts.update(:color_enabled=>RSpec::configuration.color_enabled?)
+      end
+
+      def matches?(actual)
+        @difference = DiffMatcher::Difference.new(expected, actual, @opts)
+        @difference.matching?
+      end
+
+      def failure_message_for_should
+        @difference.to_s
+      end
+    end
+
+    def be_matching(expected, opts={})
+      Matchers::BeMatching.new(expected, opts)
+    end
+  end
+end
+```
+
+And use it with:
+
+``` ruby
+describe "hash matcher" do
+  subject { { :a=>1, :b=>2, :c=>'3', :d=>4, :e=>"additional stuff" } }
+  let(:expected) { { :a=>1, :b=>Fixnum, :c=>/[0-9]/, :d=>lambda { |x| (3..5).include?(x) } } }
+
+  it { should be_matching(expected, :ignore_additional=>true) }
+  it { should be_matching(expected) }
+end
+```
+
+Will result in:
+
+```
+  Failures:
+
+    1) hash matcher
+       Failure/Error: it { should be_matching(expected) }
+         {
+           :a=>1,
+           :b=>: 2,
+           :c=>~ (3),
+           :d=>{ 4,
+         + :e=>"additional stuff"
+         }
+         Where, + 1 additional, ~ 1 match_regexp, : 1 match_class, { 1 match_proc
+      # ./hash_matcher_spec.rb:6:in `block (2 levels) in <top (required)>'
+
+Finished in 0.00601 seconds
+2 examples, 1 failure
+```
+
+
 Contributing
 ---
 

data/TODO.txt

@@ -0,0 +1,14 @@
+Fri Aug 12 2011
+ - match against class Pattern < Hash which has an :optional_keys attr (or :required_keys?)
+ - array patterns with min/max ?  (keys 0..n required?)
+
+
+Also, the words `diff` and `match` seem to get thrown around and
+interchanged a lot.
+I think I should make it clear that `diff_matcher` was built as a differ
+that outputs a textual diff based on what it matched.
+ie. by matching `actual` against an `expected` value/pattern/class/proc.
+
+Wed Dec 14 2011
+- underline
+- string diff

data/lib/diff_matcher/difference.rb

@@ -5,6 +5,50 @@ module DiffMatcher
     difference.matching? ? nil : difference.to_s
   end
 
+  class Matcher
+    attr_reader :expecteds
+
+    def self.[](*expected)
+      new(*expected)
+    end
+
+    def initialize(*expected)
+      @expecteds = [expected].flatten
+      @opts = {}
+    end
+
+    def |(other)
+      #"(#{expecteds.join(",")}|#{other.expecteds.join(",")})"
+      tap { @expecteds += other.expecteds }
+    end
+
+    def expected(expected, actual)
+      expected
+    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
+        d.matching?
+      }
+      dif
+    end
+  end
+
+  class NotAnArray < Exception; end
+  class AllMatcher < Matcher
+    def expected(expected, actual)
+      [expected]*actual.size
+    end
+
+    def diff(actual, opts={})
+      raise NotAnArray unless actual.is_a?(Array)
+      super
+    end
+  end
+
   class Difference
     RESET   = "\e[0m"
     BOLD    = "\e[1m"
@@ -16,28 +60,25 @@ module DiffMatcher
     MAGENTA = "\e[35m"
     CYAN    = "\e[36m"
 
-    COLOR_SCHEMES = {
-      :default=>{
+    DEFAULT_COLOR_SCHEME = {
         :missing       => [RED   , "-"],
         :additional    => [YELLOW, "+"],
         :match_value   => [nil   , nil],
         :match_regexp  => [GREEN , "~"],
         :match_class   => [BLUE  , ":"],
+        :match_matcher => [BLUE  , "|"],
         :match_proc    => [CYAN  , "{"]
-      },
-      :white_background=> {
-        :missing       => [RED    , "-"],
-        :additional    => [MAGENTA, "+"],
-        :match_value   => [nil    , nil],
-        :match_regexp  => [GREEN  , "~"],
-        :match_class   => [BLUE   , ":"],
-        :match_proc    => [CYAN   , "{"]
-      }
     }
 
-    attr_reader :dif
+    COLOR_SCHEMES = {
+      :default          => DEFAULT_COLOR_SCHEME,
+      :white_background => DEFAULT_COLOR_SCHEME.merge(
+        :additional    => [MAGENTA, "+"]
+      ) 
+    }
 
     def initialize(expected, actual, opts={})
+      @opts = opts
       @ignore_additional = opts[:ignore_additional]
       @quiet             = opts[:quiet]
       @color_enabled     = opts[:color_enabled] || !!opts[:color_scheme]
@@ -69,6 +110,10 @@ module DiffMatcher
       end
     end
 
+    def dif
+      @difference
+    end
+
     private
 
     def item_types
@@ -87,16 +132,16 @@ module DiffMatcher
       @matches_shown ||= lambda {
         ret = []
         unless @quiet
-          ret += [:match_class, :match_proc, :match_regexp]
+          ret += [:match_matcher, :match_class, :match_proc, :match_regexp]
           ret += [:match_value]
         end
         ret
       }.call
     end
 
-    def difference(expected, actual, reverse=false)
+    def difference(expected, actual)
       if actual.is_a? expected.class
-        left = diff(expected, actual, true)
+        left = diff(expected, actual)
         right = diff(actual, expected)
         items_to_s(
           expected,
@@ -105,18 +150,17 @@ module DiffMatcher
           }
         )
       else
-        difference_to_s(expected, actual, reverse)
+        difference_to_s(expected, actual)
       end
     end
 
-    def diff(expected, actual, reverse=false)
+    def diff(expected, actual)
       if expected.is_a?(Hash)
         expected.keys.inject({}) { |h, k|
-          h.update(k => actual.has_key?(k) ? difference(actual[k], expected[k], reverse) : expected[k])
+          h.update(k => actual.has_key?(k) ? difference(actual[k], expected[k]) : expected[k])
         }
       elsif expected.is_a?(Array)
         expected, actual = [expected, actual].map { |x| x.each_with_index.inject({}) { |h, (v, i)| h.update(i=>v) } }
-        #diff(expected, actual, reverse)  # XXX - is there a test case for this?
         diff(expected, actual)
       else
         actual
@@ -151,10 +195,13 @@ module DiffMatcher
 
     def match?(expected, actual)
       case expected
-        when Class ; [actual.is_a?(expected)                         , :match_class  ]
-        when Proc  ; [expected.call(actual)                          , :match_proc   ]
-        when Regexp; [actual.is_a?(String) && actual.match(expected) , :match_regexp ]
-        else         [actual == expected                             , :match_value  ]
+        when Matcher
+          d = expected.diff(actual, @opts)
+                      [d.nil?                                      , :match_matcher, d]
+        when Class  ; [actual.is_a?(expected)                         , :match_class  ]
+        when Proc   ; [expected.call(actual)                          , :match_proc   ]
+        when Regexp ; [actual.is_a?(String) && actual.match(expected) , :match_regexp ]
+        else          [actual == expected                             , :match_value  ]
       end
     end
 
@@ -178,12 +225,13 @@ module DiffMatcher
       markup(match_type, actual) if matches_shown.include?(match_type)
     end
 
-    def difference_to_s(expected, actual, reverse=false)
-      match, match_type = match?(*(reverse ? [actual, expected] : [expected, actual]))
+    def difference_to_s(expected, actual)
+      match, match_type, d = match?(expected, actual)
       if match
-        match_to_s(expected, actual, match_type)
+        match_to_s(expected, actual.inspect, match_type)
       else
-        "#{markup(:missing, expected.inspect)}#{markup(:additional, actual.inspect)}"
+        match_type == :match_matcher ? d :
+          "#{markup(:missing, expected.inspect)}#{markup(:additional, actual.inspect)}"
       end
     end
 

data/lib/diff_matcher/version.rb

@@ -1,3 +1,3 @@
 module DiffMatcher
-  VERSION = "2.0.1"
+  VERSION = "2.1.0"
 end

data/spec/diff_matcher/difference_spec.rb

@@ -12,34 +12,115 @@ def fix_EOF_problem(s)
   s.gsub("\n#{" " * indentation}", "\n").strip
 end
 
-describe "DiffMatcher::difference(expected, actual, opts)" do
-  subject { DiffMatcher::difference(expected, actual, opts) }
 
-  shared_examples_for "a diff matcher" do |expected, same, different, difference, opts|
-    opts ||= {}
-    context "with #{opts.size > 0 ? opts_to_s(opts) : "no opts"}" do
-      describe "difference(#{expected.inspect}, #{same.inspect}#{opts_to_s(opts)})" do
-        let(:expected) { expected }
-        let(:actual  ) { same     }
-        let(:opts    ) { opts     }
+shared_examples_for "a matcher" do |expected, expected2, same, different, difference, opts|
+  opts ||= {}
+  context "with #{opts.size > 0 ? opts_to_s(opts) : "no opts"}" do
+    describe "diff(#{same.inspect}#{opts_to_s(opts)})" do
+      let(:expected ) { expected }
+      let(:expected2) { expected }
+      let(:actual   ) { same     }
+      let(:opts     ) { opts     }
 
-        it { should be_nil }
-      end
+      it { should be_nil }
+    end
 
-      describe "difference(#{expected.inspect}, #{different.inspect}#{opts_to_s(opts)})" do
-        let(:expected) { expected  }
-        let(:actual  ) { different }
-        let(:opts    ) { opts      }
-
-        it { should_not be_nil } unless RUBY_1_9
-        it {
-          difference.is_a?(Regexp) ?
-            should =~ difference :
-            should == fix_EOF_problem(difference)
-        } if RUBY_1_9
-      end
+    describe "diff(#{different.inspect}#{opts_to_s(opts)})" do
+      let(:expected ) { expected  }
+      let(:expected2) { expected }
+      let(:actual   ) { different }
+      let(:opts     ) { opts      }
+
+      it { should_not be_nil } unless RUBY_1_9
+      it { should == fix_EOF_problem(difference)+"\n" } if RUBY_1_9
     end
   end
+end
+
+
+describe DiffMatcher::Matcher do
+  expected, expected2, same, different, difference =
+    {:nombre => String   , :edad   => Integer },
+    {: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
+
+  describe "DiffMatcher::Matcher[expected, expected2]," do
+    subject { DiffMatcher::Matcher[expected, expected2].diff(actual) }
+
+    it_behaves_like "a matcher", expected, expected2, same, different, difference
+  end
+
+  describe "DiffMatcher::Matcher[expected] | DiffMatcher::Matcher[expected2])" do
+    subject { (DiffMatcher::Matcher[expected] | DiffMatcher::Matcher[expected2]).diff(actual) }
+
+    it_behaves_like "a matcher", expected, expected2, same, different, difference
+  end
+end
+
+
+describe "DiffMatcher::AllMatcher[expected]" do
+  let(:all_matcher) { DiffMatcher::AllMatcher[expected] }
+  let(:expected ) { 1 }
+
+  describe "#diff(actual)" do
+    subject { all_matcher.diff(actual) }
+
+    context "when all match" do
+      let(:actual) { [1, 1, 1] }
+
+      it { should eql nil }
+    end
+
+    context "when not all match" do
+      let(:actual) { [1, 2, 1] }
+
+      it { should eql "[\n  1,\n  \e[31m- \e[1m1\e[0m\e[33m+ \e[1m2\e[0m,\n  1\n]\n" }
+    end
+
+    context "when actual is not an array" do
+      let(:actual) { 'a' }
+
+      it { expect { subject }.to raise_error(DiffMatcher::NotAnArray) }
+    end
+  end
+end
+
+
+shared_examples_for "a diff matcher" do |expected, same, different, difference, opts|
+  opts ||= {}
+  context "with #{opts.size > 0 ? opts_to_s(opts) : "no opts"}" do
+    describe "difference(#{expected.inspect}, #{same.inspect}#{opts_to_s(opts)})" do
+      let(:expected) { expected }
+      let(:actual  ) { same     }
+      let(:opts    ) { opts     }
+
+      it { should be_nil }
+    end
+
+    describe "difference(#{expected.inspect}, #{different.inspect}#{opts_to_s(opts)})" do
+      let(:expected) { expected  }
+      let(:actual  ) { different }
+      let(:opts    ) { opts      }
+
+      it { should_not be_nil } unless RUBY_1_9
+      it {
+        difference.is_a?(Regexp) ?
+          should =~ difference :
+          should == fix_EOF_problem(difference)
+      } if RUBY_1_9
+    end
+  end
+end
+
+describe "DiffMatcher::difference(expected, actual, opts)" do
+  subject { DiffMatcher::difference(expected, actual, opts) }
 
   describe "when expected is an instance," do
     context "of Fixnum," do
@@ -228,9 +309,7 @@ describe "DiffMatcher::difference(expected, actual, opts)" do
         Where, - 1 missing, + 1 additional
         EOF
     end
-  end
 
-  describe "when expected is," do
     context "a Regex," do
       expected, same, different =
         /[a-z]/,
@@ -253,9 +332,7 @@ describe "DiffMatcher::difference(expected, actual, opts)" do
           EOF
       end
     end
-  end
 
-  describe "when expected is," do
     context "a proc," do
       expected, same, different =
         lambda { |x| [FalseClass, TrueClass].include? x.class },
@@ -264,6 +341,110 @@ describe "DiffMatcher::difference(expected, actual, opts)" do
 
       it_behaves_like "a diff matcher", expected, same, different,
         /- #<Proc.*?>\+ \"true\"\nWhere, - 1 missing, \+ 1 additional/
+
+      context "that defines another diff matcher" do
+        expected, same, different =
+          lambda { |array| array.all? { |item| DiffMatcher::Difference.new(String, item).matching? } },
+          ["A", "B", "C"],
+          ["A", "B", 0  ]
+
+        it_behaves_like "a diff matcher", expected, same, different,
+          /- #<Proc.*?>\+ \[\"A\", \"B\", 0\]\nWhere, - 1 missing, \+ 1 additional/
+      end
+    end
+
+    context "a DiffMatcher::Matcher," do
+      expected, same, different =
+        DiffMatcher::Matcher[String],
+        "a",
+        1
+
+      it_behaves_like "a diff matcher", expected, same, different,
+        <<-EOF
+        - String+ 1
+        Where, - 1 missing, + 1 additional
+        EOF
+
+      context "or-ed with another DiffMatcher::Matcher," do
+        expected, same, different =
+          DiffMatcher::Matcher[Fixnum] | DiffMatcher::Matcher[String],
+          "a",
+          1.0
+
+        it_behaves_like "a diff matcher", expected, same, different,
+          <<-EOF
+          - String+ 1.0
+          Where, - 1 missing, + 1 additional
+          EOF
+      end
+    end
+
+    context "a DiffMatcher::AllMatcher," do
+      expected, same, different =
+        DiffMatcher::AllMatcher[String],
+        %w(ay be ci),
+        ["a", 2, "c"]
+
+      it_behaves_like "a diff matcher", expected, same, different,
+        <<-EOF
+        [
+          : "a",
+          - String+ 2,
+          : "c"
+        ]
+        Where, - 1 missing, + 1 additional, : 2 match_class
+        EOF
+
+      end
+    end
+
+    context "a DiffMatcher::AllMatcher using an or-ed DiffMatcher::Matcher," do
+      expected, same, different =
+        DiffMatcher::AllMatcher[ DiffMatcher::Matcher[Fixnum, Float] ],
+        [1, 2.0, 3],
+        [1, "2", 3]
+
+      it_behaves_like "a diff matcher", expected, same, different,
+        <<-EOF
+        [
+          | 1,
+          - Float+ "2",
+          | 3
+        ]
+        Where, - 1 missing, + 1 additional, | 2 match_matcher
+        EOF
+
+      context "more complex", do
+        expected, same, different =
+          DiffMatcher::AllMatcher[
+            DiffMatcher::Matcher[
+              {nombre:String, edad:Fixnum},
+              {name:String, age:Fixnum}
+            ]
+          ],
+          [
+            {name: "Alice", age: 10},
+            {name: "Bob"  , age: 20},
+            {name: "Con"  , age: 30}
+          ],
+          [
+            {name: "Alice", age: 10 },
+            {name: "Bob"  , age: nil},
+            {nombre: "Con"  , edad: 30 }
+          ]
+
+        it_behaves_like "a diff matcher", expected, same, different,
+          <<-EOF
+          [
+            | {:name=>"Alice", :age=>10},
+            {
+              :name=>: "Bob",
+              :age=>- Fixnum+ nil
+            },
+            | {:nombre=>"Con", :edad=>30}
+          ]
+          Where, - 1 missing, + 1 additional, : 1 match_class, | 2 match_matcher
+          EOF
     end
   end
 
@@ -279,7 +460,7 @@ describe "DiffMatcher::difference(expected, actual, opts)" do
         [
           - 1+ 0,
           2,
-          ~ (3),
+          ~ "(3)",
           : 4,
           { 5
         ]
@@ -303,7 +484,7 @@ describe "DiffMatcher::difference(expected, actual, opts)" do
         [
           - 1+ 0,
           2,
-          ~ (3),
+          ~ "(3)",
           : 4,
           { 5
         ]
@@ -317,7 +498,7 @@ describe "DiffMatcher::difference(expected, actual, opts)" do
         \e[0m[
         \e[0m  \e[31m- \e[1m1\e[0m\e[33m+ \e[1m0\e[0m,
         \e[0m  2,
-        \e[0m  \e[32m~ \e[0m\e[32m(\e[1m3\e[0m\e[32m)\e[0m\e[0m,
+        \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]
@@ -330,7 +511,7 @@ describe "DiffMatcher::difference(expected, actual, opts)" do
           \e[0m[
           \e[0m  \e[31m- \e[1m1\e[0m\e[35m+ \e[1m0\e[0m,
           \e[0m  2,
-          \e[0m  \e[32m~ \e[0m\e[32m(\e[1m3\e[0m\e[32m)\e[0m\e[0m,
+          \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]

metadata

@@ -2,7 +2,7 @@
 name: diff_matcher
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 2.0.1
+  version: 2.1.0
 platform: ruby
 authors: 
 - Playup
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-11-19 00:00:00 +11:00
+date: 2012-01-13 00:00:00 +11:00
 default_executable: 
 dependencies: []
 
@@ -32,12 +32,14 @@ extensions: []
 extra_rdoc_files: []
 
 files: 
+- .rspec
 - .travis.yml
 - CHANGELOG.md
 - Gemfile
 - License.txt
 - README.md
 - Rakefile
+- TODO.txt
 - diff_matcher.gemspec
 - doc/diff_matcher.gif
 - doc/example_output.png
@@ -60,7 +62,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: -712504035
+      hash: -331059827
       segments: 
       - 0
       version: "0"