pact 1.3.3 → 1.4.0.rc2

data/lib/pact/consumer_contract/pact_file.rb

@@ -1,24 +0,0 @@
-module Pact
-
-  module PactFile
-
-    extend self
-
-    def read uri, options = {}
-      pact = open(uri.to_s) { | file | file.read }
-      if options[:save_pactfile_to_tmp]
-        save_pactfile_to_tmp pact, ::File.basename(uri.to_s)
-      end
-      pact
-    rescue StandardError => e
-      $stderr.puts "Error reading file from #{uri}"
-      $stderr.puts "#{e.to_s} #{e.backtrace.join("\n")}"
-      raise e
-    end
-
-    def save_pactfile_to_tmp pact, name
-      ::FileUtils.mkdir_p Pact.configuration.tmp_dir
-      ::File.open(Pact.configuration.tmp_dir + "/#{name}", "w") { |file|  file << pact}
-    end
-  end
-end

data/lib/pact/consumer_contract/request.rb

@@ -1,73 +0,0 @@
-require 'pact/shared/request'
-require 'pact/shared/null_expectation'
-
-module Pact
-
-  module Request
-
-    class Expected < Pact::Request::Base
-
-      DEFAULT_OPTIONS = {:allow_unexpected_keys => false}.freeze
-      attr_accessor :options #Temporary hack
-
-      def self.from_hash(hash)
-        sym_hash = symbolize_keys hash
-        method = sym_hash.fetch(:method)
-        path = sym_hash.fetch(:path)
-        query = sym_hash.fetch(:query, key_not_found)
-        headers = sym_hash.fetch(:headers, key_not_found)
-        body = sym_hash.fetch(:body, key_not_found)
-        options = sym_hash.fetch(:options, {})
-        new(method, path, headers, body, query, options)
-      end
-
-      def initialize(method, path, headers, body, query, options = {})
-        super(method, path, headers, body, query)
-        @options = options
-      end
-
-      def matches?(actual_request)
-        difference(actual_request).empty?
-      end
-
-      def matches_route? actual_request
-        diff({:method => method, :path => path}, {:method => actual_request.method, :path => actual_request.path}).empty?
-      end
-
-      def difference(actual_request)
-        request_diff = diff(to_hash_without_body, actual_request.to_hash_without_body)
-        unless body.is_a? NullExpectation
-          request_diff.merge(body_difference(actual_request.body))
-        else
-          request_diff
-        end
-      end
-
-      protected
-
-      def self.key_not_found
-        Pact::NullExpectation.new
-      end
-
-      private
-
-      # Options is a dirty hack to allow Condor to send extra keys in the request,
-      # as it's too much work to set up an exactly matching expectation.
-      # Need to implement a proper matching strategy and remove this.
-      # Do not rely on it!
-      def runtime_options
-        DEFAULT_OPTIONS.merge(symbolize_keys(options))
-      end
-
-      def body_difference(actual_body)
-        body_differ.call({:body => body}, {body: actual_body}, allow_unexpected_keys: runtime_options[:allow_unexpected_keys_in_body])
-      end
-
-      def body_differ
-        Pact.configuration.body_differ_for_content_type content_type
-      end
-
-    end
-
-  end
-end

data/lib/pact/consumer_contract/service_consumer.rb

@@ -1,28 +0,0 @@
-require 'pact/symbolize_keys'
-
-module Pact
-  class ServiceConsumer
-    include SymbolizeKeys
-
-    attr_accessor :name
-    def initialize options
-      @name = options[:name]
-    end
-
-    def to_s
-      name
-    end
-
-    def to_hash
-      {name: name}
-    end
-
-    def as_json options = {}
-      to_hash
-    end
-
-    def self.from_hash hash
-      new(symbolize_keys(hash))
-    end
-  end
-end

data/lib/pact/consumer_contract/service_provider.rb

@@ -1,28 +0,0 @@
-require 'pact/symbolize_keys'
-
-module Pact
-  class ServiceProvider
-    include SymbolizeKeys
-
-    attr_accessor :name
-    def initialize options
-      @name = options[:name] || '[provider name unknown - please update the pact gem in the consumer project to the latest version and regenerate the pacts]'
-    end
-
-    def to_s
-      name
-    end
-
-    def to_hash
-      {name: name}
-    end
-
-    def as_json options = {}
-      to_hash
-    end
-
-    def self.from_hash hash
-      new(symbolize_keys(hash))
-    end
-  end
-end

data/lib/pact/logging.rb

@@ -1,14 +0,0 @@
-require 'logger'
-require_relative 'configuration'
-
-module Pact
-  module Logging
-    def self.included(base)
-      base.extend(self)
-    end
-
-    def logger
-      Pact.configuration.logger
-    end
-  end
-end

data/lib/pact/matchers.rb

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

data/lib/pact/matchers/actual_type.rb

@@ -1,16 +0,0 @@
-require 'pact/matchers/expected_type'
-
-
-module Pact
-  class ActualType < Pact::ExpectedType
-
-    def initialize value
-      @value = value
-    end
-
-    def to_s
-      type
-    end
-
-  end
-end

data/lib/pact/matchers/base_difference.rb

@@ -1,37 +0,0 @@
-require 'pact/matchers/expected_type'
-require 'pact/matchers/actual_type'
-
-module Pact
-  module Matchers
-    class BaseDifference
-
-      attr_reader :expected, :actual
-
-      def initialize expected, actual
-        @expected = expected
-        @actual = actual
-      end
-
-      def any?
-        true
-      end
-
-      def empty?
-        false
-      end
-
-      def to_json options = {}
-        as_json.to_json(options)
-      end
-
-      def to_s
-        as_json.to_s
-      end
-
-      def == other
-        other.class == self.class && other.expected == expected && other.actual == actual
-      end
-
-    end
-  end
-end

data/lib/pact/matchers/differ.rb

@@ -1,153 +0,0 @@
-# Ripped from RSpec::Expectations::Differ in rspec/expectations/differ.rb in rspec-expectations 2.14.3
-# Thank you kindly to the original author.
-# Needed to be able to turn the colour off, but can't set RSpec.configuration.color to false
-# once it has been set to true due to a "if bool" at the start of the color= method
-
-require 'diff/lcs'
-require 'diff/lcs/hunk'
-require 'pp'
-
-module Pact
-  module Matchers
-    class Differ
-
-      def initialize(color = false)
-        @color = color
-      end
-
-      # This is snagged from diff/lcs/ldiff.rb (which is a commandline tool)
-      def diff_as_string(input_data_new, input_data_old)
-        output = matching_encoding("", input_data_old)
-        data_old = input_data_old.split(matching_encoding("\n", input_data_old)).map! { |e| e.chomp }
-        data_new = input_data_new.split(matching_encoding("\n", input_data_new)).map! { |e| e.chomp }
-        diffs = Diff::LCS.diff(data_old, data_new)
-        return output if diffs.empty?
-        oldhunk = hunk = nil
-        file_length_difference = 0
-        diffs.each do |piece|
-          begin
-            hunk = Diff::LCS::Hunk.new(
-              data_old, data_new, piece, context_lines, file_length_difference
-            )
-            file_length_difference = hunk.file_length_difference
-            next unless oldhunk
-            # Hunks may overlap, which is why we need to be careful when our
-            # diff includes lines of context. Otherwise, we might print
-            # redundant lines.
-            if (context_lines > 0) and hunk.overlaps?(oldhunk)
-              if hunk.respond_to?(:merge)
-                # diff-lcs 1.2.x
-                hunk.merge(oldhunk)
-              else
-                # diff-lcs 1.1.3
-                hunk.unshift(oldhunk)
-              end
-            else
-              output << matching_encoding(oldhunk.diff(format).to_s, output)
-            end
-          ensure
-            oldhunk = hunk
-            output << matching_encoding("\n", output)
-          end
-        end
-        #Handle the last remaining hunk
-        output << matching_encoding(oldhunk.diff(format).to_s,output)
-        output << matching_encoding("\n",output)
-        color_diff output
-      rescue Encoding::CompatibilityError
-        if input_data_new.encoding != input_data_old.encoding
-          "Could not produce a diff because the encoding of the actual string (#{input_data_old.encoding}) "+
-          "differs from the encoding of the expected string (#{input_data_new.encoding})"
-        else
-          "Could not produce a diff because of the encoding of the string (#{input_data_old.encoding})"
-        end
-      end
-
-      def diff_as_object(actual, expected)
-        actual_as_string = object_to_string(actual)
-        expected_as_string = object_to_string(expected)
-        if diff = diff_as_string(actual_as_string, expected_as_string)
-          color_diff diff
-        end
-      end
-
-      def red(text)
-        return text unless @color
-        color(text, 31)
-      end
-
-      def green(text)
-        return text unless @color
-        color(text, 32)
-      end
-
-    protected
-
-      def format
-        :unified
-      end
-
-      def context_lines
-        3
-      end
-
-      def color(text, color_code)
-        "\e[#{color_code}m#{text}\e[0m"
-      end
-
-
-      def blue(text)
-        color(text, 34)
-      end
-
-      def color_diff(diff)
-        return diff unless @color
-
-        diff.lines.map { |line|
-          case line[0].chr
-          when "+"
-            green line
-          when "-"
-            red line
-          when "@"
-            line[1].chr == "@" ? blue(line) : line
-          else
-            line
-          end
-        }.join
-      end
-
-      def object_to_string(object)
-        case object
-        when Hash
-          object.keys.sort_by { |k| k.to_s }.map do |key|
-            pp_key   = PP.singleline_pp(key, "")
-            pp_value = PP.singleline_pp(object[key], "")
-
-            # on 1.9.3 PP seems to minimise to US-ASCII, ensure we're matching source encoding
-            #
-            # note, PP is used to ensure the ordering of the internal values of key/value e.g.
-            # <# a: b: c:> not <# c: a: b:>
-            matching_encoding("#{pp_key} => #{pp_value}", key.to_s)
-          end.join(",\n")
-        when String
-          object =~ /\n/ ? object : object.inspect
-        else
-          PP.pp(object,"")
-        end
-      end
-
-      if String.method_defined?(:encoding)
-        def matching_encoding(string, source)
-          string.encode(source.encoding)
-        end
-      else
-        def matching_encoding(string, source)
-          string
-        end
-      end
-    end
-
-  end
-end
-

data/lib/pact/matchers/difference.rb

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

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

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