pact 1.3.3 → 1.4.0.rc2

data/lib/pact/matchers/expected_type.rb

@@ -1,35 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

@@ -1,101 +0,0 @@
-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

@@ -1,139 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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

data/lib/pact/matchers/unexpected_index.rb

@@ -1,11 +0,0 @@
-require 'pact/matchers/difference_indicator'
-
-module Pact
-  class UnexpectedIndex < Pact::DifferenceIndicator
-
-    def to_s
-      '<index not to exist>'
-    end
-
-  end
-end

data/lib/pact/matchers/unexpected_key.rb

@@ -1,11 +0,0 @@
-require 'pact/matchers/difference_indicator'
-
-module Pact
-  class UnexpectedKey < Pact::DifferenceIndicator
-
-    def to_s
-      '<key not to exist>'
-    end
-
-  end
-end

data/lib/pact/matchers/unix_diff_formatter.rb

@@ -1,114 +0,0 @@
-require 'pact/shared/jruby_support'
-require 'pact/matchers/differ'
-
-module Pact
-  module Matchers
-
-    class UnixDiffFormatter
-
-      include JRubySupport
-
-      def initialize diff, options = {}
-        @diff = diff
-        @colour = options.fetch(:colour, false)
-        @differ = Pact::Matchers::Differ.new(@colour)
-      end
-
-      def self.call diff, options = {colour: Pact.configuration.color_enabled}
-        new(diff, options).call
-      end
-
-      def call
-        to_s
-      end
-
-      def to_s
-        expected = generate_string(diff, :expected)
-        actual = generate_string(diff, :actual)
-        @differ.diff_as_string(actual, expected).lstrip + "\n" + key
-      end
-
-      private
-
-      def handle thing, target
-        case thing
-        when Hash then copy_hash(thing, target)
-        when Array then copy_array(thing, target)
-        when Difference then copy_diff(thing, target)
-        when TypeDifference then copy_diff(thing, target)
-        when RegexpDifference then copy_diff(thing, target)
-        when NoDiffIndicator then copy_no_diff(thing, target)
-        else copy_object(thing, target)
-        end
-      end
-
-      def generate_string diff, target
-        comparable = handle(diff, target)
-        begin
-          # Can't think of an elegant way to check if we can pretty generate other than to try it and maybe fail
-          fix_blank_lines_in_empty_hashes JSON.pretty_generate(comparable)
-        rescue JSON::GeneratorError
-          comparable.to_s
-        end
-      end
-
-      def copy_hash hash, target
-        hash.keys.each_with_object({}) do | key, new_hash |
-          value = handle hash[key], target
-          new_hash[key] = value unless (KeyNotFound === value || UnexpectedKey === value)
-        end
-      end
-
-      def copy_array array, target
-        array.each_index.each_with_object([]) do | index, new_array |
-          value = handle array[index], target
-          new_array[index] = value unless (UnexpectedIndex === value || IndexNotFound === value)
-        end
-      end
-
-      def copy_no_diff(thing, target)
-        thing
-      end
-
-      def copy_diff difference, target
-        if target == :actual
-          handle difference.actual, target
-        else
-          handle difference.expected, target
-        end
-      end
-
-      def copy_object object, target
-        if Regexp === object
-          RegexpDecorator.new(object)
-        else
-          object
-        end
-      end
-
-      def key
-        "Key: " + @differ.red("-") + @differ.red(" means \"expected, but was not found\". \n") +
-        @differ.green("     +") + @differ.green(" means \"actual, should not be found\". \n") +
-        "     Values where the expected matches the actual are not shown.\n"
-      end
-
-      class RegexpDecorator
-
-        def initialize regexp
-          @regexp = regexp
-        end
-
-        def to_json options={}
-          @regexp.inspect
-        end
-
-        def as_json
-          @regexp.inspect
-        end
-      end
-
-      attr_reader :diff
-    end
-
-  end
-end