pact-support 0.0.1

data/lib/pact/matchers/difference.rb

@@ -0,0 +1,13 @@
+require 'pact/matchers/base_difference'
+
+module Pact
+  module Matchers
+    class Difference < BaseDifference
+
+      def as_json options = {}
+        {:EXPECTED => expected, :ACTUAL => actual}
+      end
+
+    end
+  end
+end

data/lib/pact/matchers/difference_indicator.rb

@@ -0,0 +1,26 @@
+require 'pact/shared/active_support_support'
+
+module Pact
+  class DifferenceIndicator
+
+    include ActiveSupportSupport
+
+    def == other
+      other.class == self.class
+    end
+
+    def eql? other
+      self == other
+    end
+
+    def to_json options = {}
+      remove_unicode as_json.to_json(options)
+    end
+
+    def as_json options = {}
+      to_s
+    end
+
+  end
+
+end

data/lib/pact/matchers/embedded_diff_formatter.rb

@@ -0,0 +1,62 @@
+require 'pact/shared/active_support_support'
+require 'term/ansicolor'
+
+module Pact
+  module Matchers
+    class EmbeddedDiffFormatter
+
+      include Pact::ActiveSupportSupport
+      C = ::Term::ANSIColor
+
+
+      EXPECTED = /"EXPECTED([A-Z_]*)":/
+
+      ACTUAL = /"ACTUAL([A-Z_]*)":/
+
+      attr_reader :diff, :colour
+
+      def initialize diff, options = {}
+        @diff = diff
+        @colour = options.fetch(:colour, false)
+      end
+
+      def self.call diff, options = {colour: Pact.configuration.color_enabled}
+        new(diff, options).call
+      end
+
+      def call
+        to_s
+      end
+
+      def to_hash
+        diff
+      end
+
+      def to_s
+        colourise_message_if_configured fix_json_formatting(diff.to_json)
+      end
+
+      def colourise_message_if_configured message
+        if colour
+          colourise_message message
+        else
+          message
+        end
+      end
+
+      def colourise_message message
+        message.split("\n").collect{| line | colourise(line) }.join("\n")
+      end
+
+      def colourise line
+        line.gsub(EXPECTED){|match| coloured_key match, :red }.gsub(ACTUAL){ | match | coloured_key match, :green }
+      end
+
+      def coloured_key match, colour
+        '"' + C.color(colour, match.downcase.gsub(/^"|":$/,'')) + '":'
+      end
+
+    end
+
+  end
+end

data/lib/pact/matchers/expected_type.rb

@@ -0,0 +1,35 @@
+require 'pact/matchers/difference_indicator'
+
+module Pact
+  class ExpectedType < Pact::DifferenceIndicator
+
+    def initialize value
+      @value = value
+    end
+
+    def type
+      @value.class.name
+    end
+
+    def to_json options = {}
+      type
+    end
+
+    def as_json options = {}
+      type
+    end
+
+    def eq? other
+      self.class == other.class && other.type == type
+    end
+
+    def == other
+      eq? other
+    end
+
+    def to_s
+      type
+    end
+
+  end
+end

data/lib/pact/matchers/index_not_found.rb

@@ -0,0 +1,15 @@
+require 'pact/matchers/difference_indicator'
+
+module Pact
+  class IndexNotFound < Pact::DifferenceIndicator
+
+    def to_s
+      "<index not found>"
+    end
+
+    def empty?
+      true
+    end
+  end
+
+end

data/lib/pact/matchers/list_diff_formatter.rb

@@ -0,0 +1,101 @@
+module Pact
+  module Matchers
+    class ListDiffFormatter
+
+      attr_reader :diff
+
+      def initialize diff, options = {}
+        @diff = diff
+      end
+
+      def self.call diff, options = {}
+        new(diff, options).call
+      end
+
+      def to_hash
+        diff
+      end
+
+      def call
+        to_s
+      end
+
+      def to_s
+        diff_descriptions(diff).join("\n")
+      end
+
+      def diff_descriptions obj, path = [], descriptions = []
+        case obj
+        when Hash then handle_hash obj, path, descriptions
+        when Array then handle_array obj, path, descriptions
+        when Difference then handle_difference obj, path, descriptions
+        when TypeDifference then handle_mismatched_type obj, path, descriptions
+        when RegexpDifference then handle_mismatched_regexp obj, path, descriptions
+        when NoDiffIndicator then nil
+        else
+          raise "Invalid diff, expected Hash, Array, NoDiffIndicator or Difference, found #{obj.class}"
+        end
+        descriptions
+      end
+
+      def handle_hash hash, path, descriptions
+        hash.each_pair do | key, value |
+          diff_descriptions value, path + [key.inspect], descriptions
+        end
+      end
+
+      def handle_array array, path, descriptions
+        array.each_with_index do | obj, index |
+          diff_descriptions obj, path + [index], descriptions
+        end
+      end
+
+      def handle_difference difference, path, descriptions
+        case difference.expected
+        when Pact::UnexpectedKey then handle_unexpected_key(difference, path, descriptions)
+        when Pact::UnexpectedIndex then handle_unexpected_index(difference, path, descriptions)
+        else
+          case difference.actual
+          when Pact::KeyNotFound then handle_key_not_found(difference, path, descriptions)
+          when Pact::IndexNotFound then handle_index_not_found(difference, path, descriptions)
+          else
+            handle_mismatched_value(difference, path, descriptions)
+          end
+        end
+      end
+
+      def handle_unexpected_index difference, path, descriptions
+        descriptions << "\tAt:\n\t\t#{path_to_s(path)}\n\tArray contained unexpected item:\n\t\t#{difference.actual.ai}"
+      end
+
+      def handle_mismatched_value difference, path, descriptions
+        descriptions << "\tAt:\n\t\t#{path_to_s(path)}\n\tExpected:\n\t\t#{difference.expected.ai}\n\tActual:\n\t\t#{difference.actual.ai}"
+      end
+
+      def handle_mismatched_regexp difference, path, descriptions
+        descriptions << "\tAt:\n\t\t#{path_to_s(path)}\n\tExpected to match:\n\t\t#{difference.expected.inspect}\n\tActual:\n\t\t#{difference.actual.ai}"
+      end
+
+      def handle_mismatched_type difference, path, descriptions
+        descriptions << "\tAt:\n\t\t#{path_to_s(path)}\n\tExpected type:\n\t\t#{difference.expected}\n\tActual type:\n\t\t#{difference.actual}"
+      end
+
+      def handle_index_not_found difference, path, descriptions
+        descriptions << "\tAt:\n\t\t#{path_to_s(path)}\n\tMissing index with value:\n\t\t#{difference.expected.ai}"
+      end
+
+      def handle_key_not_found difference, path, descriptions
+        descriptions << "\tAt:\n\t\t#{path_to_s(path)}\n\tMissing key with value:\n\t\t#{difference.expected.ai}"
+      end
+
+      def handle_unexpected_key difference, path, descriptions
+        descriptions << "\tAt:\n\t\t#{path_to_s(path)}\n\tHash contained unexpected key with value:\n\t\t#{difference.actual.ai}"
+      end
+
+      def path_to_s path
+        "[" + path.join("][") + "]"
+      end
+
+    end
+  end
+end

data/lib/pact/matchers/matchers.rb

@@ -0,0 +1,139 @@
+require 'awesome_print'
+require 'pact/term'
+require 'pact/something_like'
+require 'pact/shared/null_expectation'
+require 'pact/shared/key_not_found'
+require 'pact/matchers/unexpected_key'
+require 'pact/matchers/unexpected_index'
+require 'pact/matchers/index_not_found'
+require 'pact/matchers/difference'
+require 'pact/matchers/regexp_difference'
+require 'pact/matchers/type_difference'
+require 'pact/matchers/expected_type'
+require 'pact/matchers/actual_type'
+require 'pact/matchers/no_diff_indicator'
+
+module Pact
+  module Matchers
+
+    NO_DIFF_INDICATOR = NoDiffIndicator.new
+    DEFAULT_OPTIONS = {allow_unexpected_keys: true, type: false}.freeze
+
+    def diff expected, actual, opts = {}
+      calculate_diff(Pact::Term.unpack_regexps(expected), actual, DEFAULT_OPTIONS.merge(opts))
+    end
+
+    def type_diff expected, actual, opts = {}
+      calculate_diff Pact::Term.unpack_regexps(expected), actual, DEFAULT_OPTIONS.merge(opts).merge(type: true)
+    end
+
+    private
+
+    def calculate_diff expected, actual, opts = {}
+      options = DEFAULT_OPTIONS.merge(opts)
+      case expected
+      when Hash then hash_diff(expected, actual, options)
+      when Array then array_diff(expected, actual, options)
+      when Regexp then regexp_diff(expected, actual, options)
+      when Pact::SomethingLike then calculate_diff(expected.contents, actual, options.merge(:type => true))
+      else object_diff(expected, actual, options)
+      end
+    end
+
+    alias_method :structure_diff, :type_diff # Backwards compatibility
+
+    def regexp_diff regexp, actual, options
+      if actual.is_a?(String) && regexp.match(actual)
+        {}
+      else
+        RegexpDifference.new regexp, actual
+      end
+    end
+
+    def array_diff expected, actual, options
+      if actual.is_a? Array
+        actual_array_diff expected, actual, options
+      else
+        Difference.new expected, actual
+      end
+    end
+
+    def actual_array_diff expected, actual, options
+      difference = []
+      diff_found = false
+      length = [expected.length, actual.length].max
+      length.times do | index|
+        expected_item = expected.fetch(index, Pact::UnexpectedIndex.new)
+        actual_item = actual.fetch(index, Pact::IndexNotFound.new)
+        if (item_diff = calculate_diff(expected_item, actual_item, options)).any?
+          diff_found = true
+          difference << item_diff
+        else
+          difference << NO_DIFF_INDICATOR
+        end
+      end
+      diff_found ? difference : {}
+    end
+
+    def actual_hash_diff expected, actual, options
+      difference = expected.keys.inject({}) do |calculate_diff, key|
+        if (diff_at_key = calculate_diff(expected[key], actual.fetch(key, Pact::KeyNotFound.new), options)).any?
+          calculate_diff[key] = diff_at_key
+        end
+        calculate_diff
+      end
+      difference.merge(check_for_unexpected_keys(expected, actual, options))
+    end
+
+    def check_for_unexpected_keys expected, actual, options
+      if options[:allow_unexpected_keys]
+        {}
+      else
+        (actual.keys - expected.keys).inject({}) do | calculate_diff, key |
+          calculate_diff[key] = Difference.new(UnexpectedKey.new, actual[key])
+          calculate_diff
+        end
+      end
+    end
+
+    def hash_diff expected, actual, options
+      if actual.is_a? Hash
+        actual_hash_diff expected, actual, options
+      else
+        Difference.new expected, actual
+      end
+    end
+
+    def type_difference expected, actual
+      if types_match? expected, actual
+        {}
+      else
+        TypeDifference.new type_diff_expected_display(expected), type_diff_actual_display(actual)
+      end
+    end
+
+    def type_diff_actual_display actual
+      actual.is_a?(KeyNotFound) ?  actual : ActualType.new(actual)
+    end
+
+    def type_diff_expected_display expected
+      ExpectedType.new(expected)
+    end
+
+    def types_match? expected, actual
+      #There must be a more elegant way to do this
+      expected.class == actual.class ||
+        (expected.is_a?(TrueClass) && actual.is_a?(FalseClass)) ||
+          (expected.is_a?(FalseClass) && actual.is_a?(TrueClass))
+    end
+
+    def object_diff expected, actual, options
+      return type_difference(expected, actual) if options[:type]
+      if expected != actual
+        Difference.new expected, actual
+      else
+        {}
+      end
+    end
+  end
+end

data/lib/pact/matchers/no_diff_indicator.rb

@@ -0,0 +1,18 @@
+module Pact
+  module Matchers
+    class NoDiffIndicator
+
+      def to_json options = {}
+        to_s
+      end
+
+      def to_s
+        'no difference here!'
+      end
+
+      def == other
+        other.is_a? NoDiffIndicator
+      end
+    end
+  end
+end

data/lib/pact/matchers/regexp_difference.rb

@@ -0,0 +1,13 @@
+require 'pact/matchers/base_difference'
+
+module Pact
+  module Matchers
+    class RegexpDifference < BaseDifference
+
+      def as_json options = {}
+        {:EXPECTED_TO_MATCH => expected.inspect, :ACTUAL => actual}
+      end
+
+    end
+  end
+end

data/lib/pact/matchers/type_difference.rb

@@ -0,0 +1,16 @@
+require 'pact/matchers/base_difference'
+
+module Pact
+  module Matchers
+    class TypeDifference < BaseDifference
+
+      def as_json options = {}
+        if KeyNotFound === actual
+          {:EXPECTED_TYPE => expected.as_json, :ACTUAL => actual.as_json }
+        else
+          {:EXPECTED_TYPE => expected.as_json, :ACTUAL_TYPE => actual.as_json }
+        end
+      end
+    end
+  end
+end