pact 1.3.3 → 1.4.0.rc2

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

data/lib/pact/shared/null_expectation.rb

@@ -1,31 +0,0 @@
-module Pact
-  class NullExpectation
-    def to_s
-      "<No expectation>"
-    end
-
-    def ==(other_object)
-     other_object.is_a? NullExpectation
-    end
-
-    def ===(other_object)
-     other_object.is_a? NullExpectation
-    end
-
-    def eql?(other_object)
-      self == other_object
-    end
-
-    def hash
-      2934820948209428748274238642672
-    end
-
-    def empty?
-      true
-    end
-
-    def nil?
-      true
-    end
-  end
-end

data/lib/pact/shared/request.rb

@@ -1,80 +0,0 @@
-require 'pact/matchers'
-require 'pact/symbolize_keys'
-require 'pact/consumer_contract/headers'
-
-module Pact
-
-  module Request
-
-    class Base
-      include Pact::Matchers
-      include Pact::SymbolizeKeys
-      extend Pact::Matchers
-
-      attr_reader :method, :path, :headers, :body, :query, :options
-
-      def initialize(method, path, headers, body, query)
-        @method = method.to_s
-        @path = path.chomp('/')
-        @headers = Hash === headers ? Headers.new(headers) : headers # Could be a NullExpectation - TODO make this more elegant
-        @body = body
-        @query = query
-      end
-
-      def to_json(options = {})
-        as_json.to_json(options)
-      end
-
-      def as_json options = {}
-        to_hash
-      end
-
-      def to_hash
-        hash = {
-          method: method,
-          path: path,
-        }
-
-        hash.merge!(query: query) unless query.is_a? self.class.key_not_found.class
-        hash.merge!(headers: headers) unless headers.is_a? self.class.key_not_found.class
-        hash.merge!(body: body) unless body.is_a? self.class.key_not_found.class
-        hash
-      end
-
-      def method_and_path
-        "#{method.upcase} #{full_path}"
-      end
-
-      def full_path
-        display_path + display_query
-      end
-
-      def content_type
-        return nil if headers.is_a? self.class.key_not_found.class
-        headers['Content-Type']
-      end
-
-      protected
-
-      def self.key_not_found
-        raise NotImplementedError
-      end
-
-      def to_hash_without_body
-        keep_keys = [:method, :path, :headers, :query]
-        as_json.reject{ |key, value| !keep_keys.include? key }.tap do | hash |
-          hash[:method] = method.upcase
-        end
-      end
-
-      def display_path
-        path.empty? ? "/" : path
-      end
-
-      def display_query
-        (query.nil? || query.empty?) ? '' : "?#{Pact::Reification.from_term(query)}"
-      end
-
-    end
-  end
-end

data/lib/pact/shared/text_differ.rb

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

data/lib/pact/something_like.rb

@@ -1,49 +0,0 @@
-require 'pact/symbolize_keys'
-module Pact
-
-  # Specifies that the actual object should be considered a match if
-  # it includes the same keys, and the values of the keys are of the same class.
-
-  class SomethingLike
-    include SymbolizeKeys
-
-    attr_reader :contents
-
-    def initialize contents
-      @contents = contents
-    end
-
-    def to_hash
-      {
-        :json_class => self.class.name,
-        :contents => contents
-      }
-    end
-
-    def as_json
-      to_hash
-    end
-
-    def to_json opts = {}
-      as_json.to_json opts
-    end
-
-    def self.json_create hash
-      new(symbolize_keys(hash)[:contents])
-    end
-
-    def eq other
-      self == other
-    end
-
-    def == other
-      other.is_a?(SomethingLike) && other.contents == self.contents
-    end
-
-    def generate
-      contents
-    end
-  end
-end
-
-