pact 1.3.3 → 1.4.0

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

data/lib/pact/matchers.rb

@@ -1 +0,0 @@
-require_relative 'matchers/matchers'

data/lib/pact/reification.rb

@@ -1,28 +0,0 @@
-require 'randexp'
-
-module Pact
-  module Reification
-
-    def self.from_term(term)
-      case term
-      when Pact::Term, Regexp, Pact::SomethingLike
-        term.generate
-      when Hash
-        term.inject({}) do |mem, (key,term)|
-          mem[key] = from_term(term)
-        mem
-        end
-      when Array
-        term.inject([]) do |mem, term|
-          mem << from_term(term)
-          mem
-        end
-      when Pact::Request::Base
-        from_term(term.to_hash)
-      else
-        term
-      end
-    end
-
-  end
-end

data/lib/pact/rspec.rb

@@ -1,53 +0,0 @@
-require 'rspec'
-# This is horrible, must work out a better way of doing this
-module Pact
-  module RSpec
-
-    def self.color_enabled?
-      if ::RSpec.configuration.respond_to?(:color_enabled?)
-        ::RSpec.configuration.color_enabled?(::RSpec.configuration.output_stream)
-      else
-        ::RSpec.configuration.color_enabled?
-      end
-    end
-
-    def self.formatter_class
-      if ::RSpec::Core::Formatters.respond_to?(:register)
-        require 'pact/provider/rspec/formatter_rspec_3'
-        Pact::Provider::RSpec::Formatter
-      else
-        require 'pact/provider/rspec/formatter_rspec_2'
-        Pact::Provider::RSpec::Formatter2
-      end
-
-    end
-
-    def self.full_description example
-      example.respond_to?(:full_description) ? example.full_description : example.example.full_description
-    end
-
-    def self.runner_defined?
-      defined?(::RSpec::Core::Runner)
-    end
-
-    def self.is_rspec_3
-      ::RSpec::Core::Formatters.respond_to?(:register)
-    end
-
-    def self.is_rspec_2
-      !is_rspec_3
-    end
-
-    def self.with_rspec_3
-      if is_rspec_3
-        yield
-      end
-    end
-
-    def self.with_rspec_2
-      if is_rspec_2
-        yield
-      end
-    end
-  end
-end

data/lib/pact/shared/active_support_support.rb

@@ -1,51 +0,0 @@
-module Pact
-  module ActiveSupportSupport
-
-    extend self
-
-    def fix_all_the_things thing
-      if thing.is_a?(Regexp)
-        fix_regexp(thing)
-      elsif thing.is_a?(Array)
-        thing.each{ | it | fix_all_the_things it }
-      elsif thing.is_a?(Hash)
-          thing.values.each{ | it | fix_all_the_things it }
-      elsif thing.class.name.start_with?("Pact")
-        thing.instance_variables.collect{ | iv_name | thing.instance_variable_get(iv_name)}.each do | iv |
-          fix_all_the_things iv
-        end
-      end
-      thing
-    end
-
-    # ActiveSupport JSON overwrites (i.e. TRAMPLES) the json methods of the Regexp class directly
-    # (beneath its destructive hooves of destruction).
-    # This does not seem to be able to be undone without affecting the JSON serialisation in the
-    # calling project, so the best way I've found to fix this issue is to reattach the
-    # original as_json to the Regexp instances in the ConsumerContract before we write them to the
-    # pact file. If anyone can find a better way, please submit a pull request ASAP!
-    def fix_regexp regexp
-      def regexp.as_json options = {}
-        {:json_class => 'Regexp', "o" => self.options, "s" => self.source }
-      end
-      regexp
-    end
-
-    # Having Active Support JSON loaded somehow kills the formatting of pretty_generate for objects.
-    # Don't ask me why, but it still seems to work for hashes, so the hacky work around is to
-    # reparse the generated JSON into a hash and pretty_generate that... sigh...
-    # Oh ActiveSupport, why....
-    def fix_json_formatting json
-      if json.include?("\n")
-        json
-      else
-        JSON.pretty_generate(JSON.parse(json, create_additions: false))
-      end
-    end
-
-    def remove_unicode json
-      json.gsub(/\\u([0-9A-Za-z]{4})/) {|s| [$1.to_i(16)].pack("U")}
-    end
-
-  end
-end

data/lib/pact/shared/dsl.rb

@@ -1,76 +0,0 @@
-module Pact
-
-  class DslDelegator
-
-    def initialize delegation_target
-      @delegation_target = delegation_target
-    end
-
-    def instance_eval_with_previous_context_available(*args, &block)
-      with_previous_context_available(block.binding) do
-        bind_block_as_instance_method_on_self(&block).call(*args)
-      end
-    end
-
-    protected
-
-    def method_missing(method, *args, &block)
-      if delegation_target_responds_to? method
-        delegation_target.send(method, *args, &block)
-      else
-        previous_context.send(method, *args, &block)
-      end
-    end
-
-    private
-
-    attr_accessor :delegation_target, :previous_context
-
-    def bind_block_as_instance_method_on_self(&block)
-      create_instance_method_from_block(&block).bind(self)
-    end
-
-
-    def create_instance_method_from_block &block
-      meth = self.class.class_eval do
-        define_method :block_as_instance_method_, &block
-        meth = instance_method :block_as_instance_method_
-        remove_method :block_as_instance_method_
-        meth
-      end
-    end
-
-    def with_previous_context_available(binding, &block)
-      @previous_context = binding.eval('self')
-      result = block.call
-      @previous_context = nil
-      result
-    end
-
-    def delegation_target_responds_to?(method)
-      delegation_target.respond_to? method
-    end
-
-  end
-
-
-  # Ripped from http://blog.joecorcoran.co.uk/2013/09/04/simple-pattern-ruby-dsl
-  # and then fixed up by using http://www.skorks.com/2013/03/a-closure-is-not-always-a-closure-in-ruby/
-  # to access variables and methods defined in the calling scope.
-  module DSL
-    def build(*args, &block)
-      new_instance_of_delegation_target_class = self.new(*args)
-      dsl_delegator_class = self.const_get('DSL_DELEGATOR_CLASS')
-      dsl_delegator = dsl_delegator_class.new(new_instance_of_delegation_target_class)
-      dsl_delegator.instance_eval_with_previous_context_available(&block)
-      new_instance_of_delegation_target_class.finalize
-      new_instance_of_delegation_target_class
-    end
-
-    def dsl(&block)
-      dsl_delegator_class = Class.new(DslDelegator, &block)
-      self.const_set('DSL_DELEGATOR_CLASS', dsl_delegator_class)
-    end
-
-  end
-end

data/lib/pact/shared/jruby_support.rb

@@ -1,18 +0,0 @@
-module Pact
-  module JRubySupport
-
-    # Under jruby, JSON.pretty_generate inserts a blank new line between the opening and closing
-    # brackets of an empty hash, like so:
-    # {
-    #   "empty": {
-    #
-    #   }
-    # }
-    # This screws up the UnixDiffFormatter, so we need to remove the blank lines.
-
-    def fix_blank_lines_in_empty_hashes json
-      json.gsub(/({\n)\n(\s*})/,'\1\2')
-    end
-
-  end
-end

data/lib/pact/shared/json_differ.rb

@@ -1,15 +0,0 @@
-require 'pact/matchers/matchers'
-
-module Pact
-  class JsonDiffer
-
-    extend Matchers
-
-
-    def self.call expected, actual, options = {}
-      diff expected, actual, options
-    end
-
-
-  end
-end

data/lib/pact/shared/key_not_found.rb

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