diff_matcher 1.0.0

data/Gemfile

@@ -0,0 +1,9 @@
+source "http://rubygems.org"
+
+gemspec
+
+group :test do
+  gem "rake"
+  gem "rspec" #, "~> 2.0.1"
+  gem "simplecov"
+end

data/License.txt

@@ -0,0 +1,22 @@
+(The MIT License)
+
+Copyright (c) 2011 PlayUp
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,178 @@
+DiffMatcher
+===
+
+[![build status](http://travis-ci.org/playup/diff_matcher.png)](http://travis-ci.org/playup/diff_matcher)
+
+Generates a diff by matching against expected values, classes, regexes and/or procs.
+
+DiffMatcher performs recursive matches on values contained in hashes, arrays and combinations thereof.
+
+Values in a containing object match when:
+
+    - actual == expected
+    - actual.is_a? expected  # when expected is a class
+    - expected.match actual  # when expected is a regexp
+    - expected.call actual   # when expected is a proc
+
+
+Installation
+---
+
+    gem install diff_matcher
+
+
+Usage
+---
+
+    require 'diff_matcher'
+    
+    DiffMatcher::difference(actual, expected, opts={})
+
+When `expected` != `actual`
+
+    puts DiffMatcher::difference(1, 2)
+    # => - 1+ 2
+    # => Where, - 1 missing, + 1 additional
+
+When `expected` == `actual`
+
+    p DiffMatcher::difference(1, 1)
+    # => nil
+
+When `actual` is an instance of the `expected`
+
+    p DiffMatcher::difference(String, '1')
+    # => nil
+
+When `actual` is a string that matches the `expected` regex
+
+    p DiffMatcher::difference(/[a-z]/, "a")
+    # => nil
+
+When `actual` is passed to an `expected` proc and it returns true
+
+    is_boolean = lambda { |x| [FalseClass, TrueClass].include? x.class }
+    p DiffMatcher::difference(is_boolean, true)
+    # => nil
+
+When `actual` is missing one of the `expected` values
+
+    puts DiffMatcher::difference([1, 2], [1])
+    # => [
+    # => - 2
+    # => ]
+    # => Where, - 1 missing
+
+When `actual` has additional values to the `expected`
+
+    puts DiffMatcher::difference([1], [1, 2])
+    # => [
+    # => + 2
+    # => ]
+    # => Where, - 1 additional
+
+### Options
+
+`:ignore_additional=>true` will match even if `actual` has additional items
+
+    p DiffMatcher::difference([1], [1, 2], :ignore_additional=>true)
+    # => nil
+
+`:verbose=>true` shows only missing and additional items in the output
+
+    puts DiffMatcher::difference([Fixnum, 2], [1], :quiet=>true)
+    # => [
+    # => - 2
+    # => ]
+    # => Where, - 1 missing
+
+`:verbose=>true` shows all matched items in the output
+
+    puts DiffMatcher::difference([Fixnum, 2], [1], :verbose=>true)
+    # => [
+    # = >  : 1,
+    # => - 2
+    # => ]
+    # => Where, - 1 missing, : 1 match_class
+
+#### prefixes
+
+NB. The `: 1` from above includes a `:` prefix that shows the `1` was matched against a class (ie. `Fixnum`)
+
+The items shown in a difference are prefixed as follows:
+
+    missing       => "- "
+    additional    => "+ "
+    match value   =>
+    match regexp  => "~ "
+    match class   => ": "
+    match proc    => "{ "
+
+#### colours
+
+Colours (defined in colour schemes) can also appear in the difference.
+
+Using the `:default` colour scheme items shown in a difference are coloured as follows:
+
+    missing       => red
+    additional    => yellow
+    match value   =>
+    match regexp  => green
+    match class   => blue
+    match proc    => cyan
+
+
+    puts DiffMatcher::difference(
+      { :a=>{ :a1=>11          }, :b=>[ 21, 22 ], :c=>/\d/, :d=>Fixnum, :e=>lambda { |x| (4..6).includes? x },
+      { :a=>{ :a1=>10, :a2=>12 }, :b=>[ 21     ], :c=>'3' , :d=>4     , :e=>5                               },
+      :verbose=>true, :color_scheme=>:white_background
+    )
+
+![example output](https://raw.github.com/playup/diff_matcher/master/doc/example_output.png)
+
+
+Similar gems
+---
+
+### String differs
+  * <http://difflcs.rubyforge.org> (A resonably fast diff algorithm using longest common substrings)
+  * <http://github.com/samg/diffy> (Provides a convenient interfaces to Unix diff)
+  * <http://github.com/pvande/differ> (A simple gem for generating string diffs)
+  * <http://github.com/shuber/sub_diff> (Apply regular expression replacements to strings while presenting the result in a “diff” like format)
+  * <http://github.com/rattle/diffrenderer> (Takes two pieces of source text/html and creates a neato html diff output)
+
+### Object differs
+  * <http://github.com/tinogomes/ssdiff> (Super Stupid Diff)
+  * <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)
+
+
+Why another differ?
+---
+
+This gem came about because [rspec](http://github.com/rspec/rspec-expectations) doesn't have a decent differ for matching hashes and/or JSON.
+It started out as a [pull request](http://github.com/rspec/rspec-expectations/pull/79), to be implemented as a
+`be_hash_matching` [rspec matcher](https://www.relishapp.com/rspec/rspec-expectations),
+but seemed useful enough to be its own stand alone gem.
+
+Out of the similar gems above, [easy_diff](http://github.com/Blargel/easy_diff) looks like a good alternative to this gem.
+It has extra functionality in also being able to recursively merge hashes and arrays.
+[sub_diff](http://github.com/shuber/sub_diff) can use regular expressions in its match and subsequent diff
+
+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.
+
+
+Contributing
+---
+
+Fork, write some tests and send a pull request (bonus points for topic branches).
+
+
+Status
+---
+
+Our company is using this gem to test our JSON API which has got it to a stable v1.0.0 release.
+
+There's a [pull request](http://github.com/rspec/rspec-expectations/pull/79) to use this gem in a `be_hash_matching` 
+[rspec matcher](https://www.relishapp.com/rspec/rspec-expectations).

data/Rakefile

@@ -0,0 +1,12 @@
+require 'bundler'
+
+Bundler::GemHelper.install_tasks
+
+require "rspec/core/rake_task"
+
+task "default" => "spec"
+
+RSpec::Core::RakeTask.new do |t|
+  t.pattern = 'spec/**/*_spec.rb'
+  t.rspec_opts = ["--colour", "--format", "nested"]
+end

data/diff_matcher.gemspec

@@ -0,0 +1,29 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "diff_matcher/version"
+
+Gem::Specification.new do |s|
+
+  s.name          = "diff_matcher"
+  s.version       = DiffMatcher::VERSION.dup
+  s.platform      = Gem::Platform::RUBY
+  s.authors       = ["Playup"]
+  s.email         = "chris@playup.com"
+  s.homepage      = "http://github.com/playup/diff_matcher"
+
+  s.summary       = %q{Generates a diff by matching against expected values, classes, regexes and/or procs.}
+  s.description   = <<EOF
+DiffMatcher performs recursive matches on values contained in hashes, arrays and combinations thereof.
+
+Values in a containing object match when:
+
+    - actual == expected
+    - actual.is_a? expected  # when expected is a class
+    - expected.match actual  # when expected is a regexp
+    - expected.call actual   # when expected is a proc
+EOF
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.require_paths = ["lib"]
+end

data/lib/diff_matcher.rb

@@ -0,0 +1,2 @@
+require 'diff_matcher/difference'
+require 'diff_matcher/version'

data/lib/diff_matcher/difference.rb

@@ -0,0 +1,200 @@
+module DiffMatcher
+
+  def self.difference(expected, actual, opts={})
+    difference = Difference.new(expected, actual, opts)
+    difference.matching? ? nil : difference.to_s
+  end
+
+  class Difference
+    RESET   = "\e[0m"
+    BOLD    = "\e[1m"
+
+    RED     = "\e[31m"
+    GREEN   = "\e[32m"
+    YELLOW  = "\e[33m"
+    BLUE    = "\e[34m"
+    MAGENTA = "\e[35m"
+    CYAN    = "\e[36m"
+
+    COLOR_SCHEMES = {
+      :default=>{
+        :missing       => [RED   , "-"],
+        :additional    => [YELLOW, "+"],
+        :match_value   => [nil   , nil],
+        :match_regexp  => [GREEN , "~"],
+        :match_class   => [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
+
+    def initialize(expected, actual, opts={})
+      @ignore_additional = opts[:ignore_additional]
+      @quiet             = opts[:quiet]
+      @verbose           = opts[:verbose]
+      @color_enabled     = opts[:color_enabled] || !!opts[:color_scheme]
+      @color_scheme      = COLOR_SCHEMES[opts[:color_scheme] || :default]
+      @difference = difference(expected, actual)
+    end
+
+    def matching?
+      @match ||= @difference ? item_types.map { |item_type|
+        @color_scheme[item_type]
+      }.reduce(0) { |count, (color, prefix)|
+        count + @difference.scan("#{color}#{prefix}").size
+      } == 0 : true
+    end
+
+    def to_s
+      if @difference
+        msg = "\e[0m" + @difference.split("\n").join("\n\e[0m")
+        where = @color_scheme.keys.collect { |item_type|
+          unless item_type == :match_value
+            color, prefix = @color_scheme[item_type]
+            count = msg.scan("#{color}#{prefix}").size
+            "#{color}#{prefix} #{BOLD}#{count} #{item_type}#{RESET}" if count > 0
+          end
+        }.compact.join(", ")
+        msg <<  "\nWhere, #{where}" if where.size > 0
+
+        @color_enabled ? msg : msg.gsub(/\e\[\d+m/, "")
+      end
+    end
+
+    private
+
+    def item_types
+      @item_types ||= @ignore_additional ? [:missing] : [:missing, :additional]
+    end
+
+    def item_types_shown
+      @item_types_shown ||= lambda {
+        ret = [:different] + item_types
+        ret += [:additional] unless @quiet
+        ret.uniq
+      }.call
+    end
+
+    def matches_shown
+      @matches_shown ||= lambda {
+        ret = []
+        unless @quiet
+          ret += [:match_class, :match_proc, :match_regexp]
+          ret += [:match_value] if @verbose
+        end
+        ret
+      }.call
+    end
+
+    def difference(expected, actual, reverse=false)
+      if actual.is_a? expected.class
+        left = diff(expected, actual, true)
+        right = diff(actual, expected)
+        items_to_s(
+          expected,
+          (item_types_shown).reduce([]) { |a, method|
+            a + send(method, left, right, expected.class).compact.map { |item| markup(method, item) }
+          }
+        )
+      else
+        difference_to_s(expected, actual, reverse)
+      end
+    end
+
+    def diff(expected, actual, reverse=false)
+      if expected.is_a?(Hash)
+        expected.keys.reduce({}) { |h, k|
+          h.update(k => actual.has_key?(k) ? difference(actual[k], expected[k], reverse) : expected[k])
+        }
+      elsif expected.is_a?(Array)
+        expected, actual = [expected, actual].map { |x| x.each_with_index.reduce({}) { |h, (v, i)| h.update(i=>v) } }
+        #diff(expected, actual, reverse)  # XXX - is there a test case for this?
+        diff(expected, actual)
+      else
+        actual
+      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|
+          yield k
+        }
+      else
+        [default]
+      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)
+      }
+   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)
+      }
+   end
+
+    def additional(left, right, expected_class)
+      missing(right, left, expected_class)
+    end
+
+    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  ]
+      end
+    end
+
+    def items_to_s(expected, items)
+      case expected
+        when Hash ; "{\n#{items.join(",\n")}\n}\n"
+        when Array; "[\n#{items.join(",\n")}\n]\n"
+        else items.join.strip
+      end if items.size > 0
+    end
+
+    def match_regexp_to_s(expected, actual)
+      if actual.is_a? String
+        color, prefix = @color_scheme[:match_regexp]
+        actual.sub(expected, "#{color}(\e[1m#{actual[expected, 0]}#{RESET}#{color})#{RESET}")
+      end
+    end
+
+    def match_to_s(expected, actual, match_type)
+      actual = match_regexp_to_s(expected, actual) if match_type == :match_regexp
+      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])
+      if match
+        match_to_s(expected, actual, match_type)
+      else
+        "#{markup(:missing, expected.inspect)}#{markup(:additional, actual.inspect)}"
+      end
+    end
+
+    def markup(item_type, item)
+      if item_type == :different
+        item.split("\n").map {|line| "  #{line}"}.join("\n") if item
+      else
+        color, prefix = @color_scheme[item_type]
+        "#{color}#{prefix+' ' if prefix}#{BOLD if color and item_type != :match_regexp}#{RESET if item_type == :match_regexp}#{item}#{RESET if color}" if item
+      end if item
+    end
+  end
+end

data/lib/diff_matcher/version.rb

@@ -0,0 +1,3 @@
+module DiffMatcher
+  VERSION = "1.0.0"
+end

data/spec/diff_matcher/difference_spec.rb

@@ -0,0 +1,351 @@
+require "spec_helper"
+
+RUBY_1_9 = (RUBY_VERSION =~ /^1\.9/)
+
+def opts_to_s(opts)
+  opts_strs = opts.map { |k,v| ":#{k}=>#{v}" if v }.compact
+  opts_strs.size > 0 ? ", " + opts_strs * ", " : ""
+end
+
+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
+end
+
+describe DiffMatcher do
+  subject { DiffMatcher::difference(expected, actual, opts) }
+
+  shared_examples_for "a differ" do |expected, same, different, difference="", 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 "#new(#{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 "when expected is an instance," do
+    context "of Fixnum," do
+      expected, same, different =
+        1,
+        1,
+        2
+
+      it_behaves_like "a differ", expected, same, different,
+        <<-EOF
+        - 1+ 2
+        Where, - 1 missing, + 1 additional
+        EOF
+    end
+
+    context "of String," do
+      expected, same, different =
+        "a",
+        "a",
+        "b"
+
+      it_behaves_like "a differ", expected, same, different,
+        <<-EOF
+        - "a"+ "b"
+        Where, - 1 missing, + 1 additional
+        EOF
+
+      context "when actual is of a different class" do
+        different = 0
+
+        it_behaves_like "a differ", expected, same, different,
+          <<-EOF
+          - "a"+ 0
+          Where, - 1 missing, + 1 additional
+          EOF
+      end
+
+      context "when actual is nil" do
+        different = nil
+
+        it_behaves_like "a differ", expected, same, different,
+          <<-EOF
+          - "a"+ nil
+          Where, - 1 missing, + 1 additional
+          EOF
+      end
+    end
+
+    context "of nil," do
+      expected, same, different =
+        nil,
+        nil,
+        false
+
+      it_behaves_like "a differ", expected, same, different,
+        <<-EOF
+        - nil+ false
+        Where, - 1 missing, + 1 additional
+        EOF
+    end
+
+    context "of Array," do
+      expected, same, different =
+        [ 1 ],
+        [ 1 ],
+        [ 2 ]
+
+      it_behaves_like "a differ", expected, same, different,
+        <<-EOF
+        [
+          - 1+ 2
+        ]
+        Where, - 1 missing, + 1 additional
+        EOF
+
+      context "where actual has additional items" do
+        expected, same, different =
+          [ 1, 2    ],
+          [ 1, 2, 3 ],
+          [ 0, 2, 3 ]
+
+        it_behaves_like "a differ", expected, same, different,
+          <<-EOF, :ignore_additional=>true
+          [
+            - 1+ 0,
+          + 3
+          ]
+          Where, - 1 missing, + 2 additional
+          EOF
+
+        it_behaves_like "a differ", expected, same, different,
+          <<-EOF, :ignore_additional=>true, :quiet=>true
+          [
+            - 1+ 0
+          ]
+          Where, - 1 missing, + 1 additional
+          EOF
+
+        it_behaves_like "a differ", expected, same, different,
+          <<-EOF, :ignore_additional=>true, :verbose=>true
+          [
+            - 1+ 0,
+            2,
+          + 3
+          ]
+          Where, - 1 missing, + 2 additional
+          EOF
+      end
+
+      context "where actual has missing items" do
+        expected, same, different =
+          [ 1, 2, 3 ],
+          [ 1, 2, 3 ],
+          [ 1, 2    ]
+
+        it_behaves_like "a differ", expected, same, different,
+          <<-EOF
+          [
+          - 3
+          ]
+          Where, - 1 missing
+          EOF
+
+        it_behaves_like "a differ", expected, same, different,
+          <<-EOF, :verbose=>true
+          [
+            1,
+            2,
+          - 3
+          ]
+          Where, - 1 missing
+          EOF
+      end
+    end
+
+    context "of Hash," do
+      expected, same, different =
+        { "a"=>1 },
+        { "a"=>1 },
+        { "a"=>2 }
+
+      it_behaves_like "a differ", expected, same, different,
+        <<-EOF
+        {
+          "a"=>- 1+ 2
+        }
+        Where, - 1 missing, + 1 additional
+        EOF
+
+      context "with keys of differing classes" do
+        expected, same, different =
+          { "a"=>{ "b"=>1 } },
+          { "a"=>{ "b"=>1 } },
+          { "a"=>[ "b", 1 ] }
+
+        it_behaves_like "a differ", expected, same, different,
+          <<-EOF
+          {
+            "a"=>- {"b"=>1}+ ["b", 1]
+          }
+          Where, - 1 missing, + 1 additional
+          EOF
+      end
+
+      context "with matching hash descendents" do
+        expected, same, different =
+          { "a"=>{ "b"=>{ "c"=>1 } } },
+          { "a"=>{ "b"=>{ "c"=>1 } } },
+          {        "b"=>{ "c"=>1 }   }
+
+        describe "it won't match the descendents" do
+          it_behaves_like "a differ", expected, same, different,
+            <<-EOF
+            {
+            - "a"=>{"b"=>{"c"=>1}},
+            + "b"=>{"c"=>1}
+            }
+            Where, - 1 missing, + 1 additional
+            EOF
+        end
+      end
+    end
+  end
+
+  describe "when expected is," do
+    context "a class," do
+      expected, same, different =
+        String,
+        "a",
+        1
+
+      it_behaves_like "a differ", expected, same, different,
+        <<-EOF
+        - String+ 1
+        Where, - 1 missing, + 1 additional
+        EOF
+    end
+  end
+
+  describe "when expected is," do
+    context "a Regex," do
+      expected, same, different =
+        /[a-z]/,
+        "a",
+        "A"
+
+      it_behaves_like "a differ", expected, same, different,
+        <<-EOF
+        - /[a-z]/+ "A"
+        Where, - 1 missing, + 1 additional
+        EOF
+
+      context "and when actual is not a String," do
+        different = :a
+
+        it_behaves_like "a differ", expected, same, different,
+          <<-EOF
+          - /[a-z]/+ :a
+          Where, - 1 missing, + 1 additional
+          EOF
+      end
+    end
+  end
+
+  describe "when expected is," do
+    context "a proc," do
+      expected, same, different =
+        lambda { |x| [FalseClass, TrueClass].include? x.class },
+        true,
+        "true"
+
+      it_behaves_like "a differ", expected, same, different,
+        /- #<Proc.*?>\+ \"true\"\nWhere, - 1 missing, \+ 1 additional/
+    end
+  end
+
+  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                                ]
+
+    describe "it shows regex, class, proc matches and" do
+      it_behaves_like "a differ", expected, same, different,
+        <<-EOF
+        [
+          - 1+ 0,
+          ~ (3),
+          : 4,
+          { 5
+        ]
+        Where, - 1 missing, + 1 additional, ~ 1 match_regexp, : 1 match_class, { 1 match_proc
+        EOF
+    end
+
+    describe "it doesn't show matches and" do
+      it_behaves_like "a differ", expected, same, different,
+        <<-EOF, :quiet=>true
+        [
+          - 1+ 0
+        ]
+        Where, - 1 missing, + 1 additional
+        EOF
+    end
+
+    describe "it shows all matches and" do
+      it_behaves_like "a differ", expected, same, different,
+        <<-EOF ,:verbose=>true
+        [
+          - 1+ 0,
+          2,
+          ~ (3),
+          : 4,
+          { 5
+        ]
+        Where, - 1 missing, + 1 additional, ~ 1 match_regexp, : 1 match_class, { 1 match_proc
+        EOF
+    end
+
+    describe "it shows matches in color and" do
+      it_behaves_like "a differ", expected, same, different,
+        <<-EOF ,:verbose=>true, :color_scheme=>:default
+        \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[34m: \e[1m4\e[0m,
+        \e[0m  \e[36m{ \e[1m5\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
+        EOF
+
+      context "on a white background" do
+        it_behaves_like "a differ", expected, same, different,
+          <<-EOF ,:verbose=>true, :color_scheme=>:white_background
+          \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[34m: \e[1m4\e[0m,
+          \e[0m  \e[36m{ \e[1m5\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
+          EOF
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,3 @@
+require 'simplecov'
+SimpleCov.start
+require "diff_matcher"

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification 
+name: diff_matcher
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 1.0.0
+platform: ruby
+authors: 
+- Playup
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-09-17 00:00:00 +10:00
+default_executable: 
+dependencies: []
+
+description: |
+  DiffMatcher performs recursive matches on values contained in hashes, arrays and combinations thereof.
+  
+  Values in a containing object match when:
+  
+      - actual == expected
+      - actual.is_a? expected  # when expected is a class
+      - expected.match actual  # when expected is a regexp
+      - expected.call actual   # when expected is a proc
+
+email: chris@playup.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- Gemfile
+- License.txt
+- README.md
+- Rakefile
+- diff_matcher.gemspec
+- doc/example_output.png
+- lib/diff_matcher.rb
+- lib/diff_matcher/difference.rb
+- 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: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: Generates a diff by matching against expected values, classes, regexes and/or procs.
+test_files: []
+