pact 0.1.28 → 1.3.3

data/lib/pact/doc/generator.rb

@@ -0,0 +1,82 @@
+require 'pact/doc/doc_file'
+require 'fileutils'
+
+module Pact
+  module Doc
+
+    class Generator
+
+      def initialize pact_dir, doc_dir, options
+        @doc_dir = doc_dir
+        @pact_dir = pact_dir
+        @consumer_contract_renderer = options[:consumer_contract_renderer]
+        @doc_type = options[:doc_type]
+        @file_extension = options[:file_extension]
+        @index_renderer = options[:index_renderer]
+        @index_name = options[:index_name]
+        @after = options.fetch(:after, lambda{|pact_dir, target_dir, consumer_contracts| })
+      end
+
+      def call
+        ensure_target_dir_exists_and_is_clean
+        write_index if consumer_contracts.any?
+        write_doc_files
+        perform_after_hook
+      end
+
+      private
+
+      attr_reader :doc_dir, :pact_dir, :consumer_contract_renderer, :doc_type, :file_extension, :index_renderer, :after
+
+      def write_index
+        File.open(index_file_path, "w") { |io|  io << index_file_contents }
+      end
+
+      def index_file_path
+        File.join(target_dir, "#{@index_name}#{file_extension}")
+      end
+
+      def index_file_contents
+        index_renderer.call(consumer_contracts.first.consumer.name, index_data)
+      end
+
+      def index_data
+        doc_files.each_with_object({}) do | doc_file, data |
+          data[doc_file.title] = doc_file.name
+        end
+      end
+
+      def write_doc_files
+        doc_files.each(&:write)
+      end
+
+      def doc_files
+        consumer_contracts.collect do | consumer_contract |
+          DocFile.new(consumer_contract, target_dir, consumer_contract_renderer, file_extension)
+        end
+      end
+
+      def consumer_contracts
+        @consumer_contracts ||= begin
+          Dir.glob("#{pact_dir}/**").collect do |file|
+            Pact::ConsumerContract.from_uri file
+          end
+        end
+      end
+
+      def perform_after_hook
+        after.call(pact_dir, target_dir, consumer_contracts)
+      end
+
+      def ensure_target_dir_exists_and_is_clean
+        FileUtils.rm_rf target_dir
+        FileUtils.mkdir_p target_dir
+      end
+
+      def target_dir
+        File.join(doc_dir, doc_type)
+      end
+
+    end
+  end
+end

data/lib/pact/doc/interaction_view_model.rb

@@ -0,0 +1,114 @@
+require 'pact/shared/active_support_support'
+require 'pact/reification'
+
+module Pact
+  module Doc
+    class InteractionViewModel
+
+      include Pact::ActiveSupportSupport
+
+      def initialize interaction, consumer_contract
+        @interaction = interaction
+        @consumer_contract = consumer_contract
+      end
+
+      def id
+        @id ||= begin
+          if has_provider_state?
+            "#{description} given #{interaction.provider_state}"
+          else
+            interaction.description
+          end.gsub(/\s+/,'_')
+        end
+      end
+
+      def request_method
+        interaction.request.method.upcase
+      end
+
+      def request_path
+        interaction.request.path
+      end
+
+      def response_status
+        interaction.response['status']
+      end
+
+      def consumer_name
+        @consumer_contract.consumer.name
+      end
+
+      def provider_name
+        @consumer_contract.provider.name
+      end
+
+      def has_provider_state?
+        @interaction.provider_state && !@interaction.provider_state.empty?
+      end
+
+      def provider_state start_of_sentence = false
+        apply_capitals(@interaction.provider_state.strip, start_of_sentence)
+      end
+
+      def description start_of_sentence = false
+        apply_capitals(@interaction.description.strip, start_of_sentence)
+      end
+
+      def request
+        fix_json_formatting JSON.pretty_generate(clean_request)
+      end
+
+      def response
+        fix_json_formatting JSON.pretty_generate(clean_response)
+      end
+
+      private
+
+      attr_reader :interaction, :consumer_contract
+
+      def clean_request
+        ordered_clean_hash Reification.from_term(interaction.request)
+      end
+
+      def clean_response
+        ordered_clean_hash Reification.from_term(interaction.response)
+      end
+
+      # Remove empty body and headers hashes from response, and empty headers from request,
+      # as an empty hash means "allow anything" - it's more intuitive and cleaner to just
+      # remove the empty hashes from display.
+      def ordered_clean_hash source
+        ordered_keys.each_with_object({}) do |key, target|
+          if source.key? key
+            target[key] = source[key] unless value_is_an_empty_hash_that_is_not_request_body(source[key], key)
+          end
+        end
+      end
+
+      def value_is_an_empty_hash_that_is_not_request_body value, key
+        value.is_a?(Hash) && value.empty? && key != :body
+      end
+
+      def ordered_keys
+        [:method, :path, :query, :headers, :body, "status", "headers","body"]
+      end
+
+      def remove_key_if_empty key, hash
+        hash.delete(key) if hash[key].is_a?(Hash) && hash[key].empty?
+      end
+
+      def apply_capitals string, start_of_sentence = false
+        start_of_sentence ? capitalize_first_letter(string) : lowercase_first_letter(string)
+      end
+
+      def capitalize_first_letter string
+        string[0].upcase + string[1..-1]
+      end
+
+      def lowercase_first_letter string
+        string[0].downcase + string[1..-1]
+      end
+
+    end
+  end
+end

data/lib/pact/doc/markdown/consumer_contract_renderer.rb

@@ -0,0 +1,56 @@
+require 'pact/doc/markdown/interaction_renderer'
+require 'pact/doc/sort_interactions'
+
+module Pact
+  module Doc
+    module Markdown
+      class ConsumerContractRenderer
+
+        def initialize consumer_contract
+          @consumer_contract = consumer_contract
+        end
+
+        def self.call consumer_contract
+          new(consumer_contract).call
+        end
+
+        def call
+          title + summaries_title + summaries.join + interactions_title + full_interactions.join
+        end
+
+        private
+
+        attr_reader :consumer_contract
+
+        def title
+          "### A pact between #{consumer_contract.consumer.name} and #{consumer_contract.provider.name}\n\n"
+        end
+
+        def interaction_renderers
+          @interaction_renderers ||= sorted_interactions.collect{|interaction| InteractionRenderer.new interaction, @consumer_contract}
+        end
+
+        def summaries_title
+          "#### Requests from #{consumer_contract.consumer.name} to #{consumer_contract.provider.name}\n\n"
+        end
+
+        def interactions_title
+          "#### Interactions\n\n"
+        end
+
+        def summaries
+          interaction_renderers.collect(&:render_summary)
+        end
+
+        def full_interactions
+          interaction_renderers.collect(&:render_full_interaction)
+        end
+
+        def sorted_interactions
+          SortInteractions.call(consumer_contract.interactions)
+        end
+
+      end
+    end
+  end
+end

data/lib/pact/doc/markdown/generator.rb

@@ -0,0 +1,26 @@
+require 'pact/doc/generator'
+require 'pact/doc/markdown/consumer_contract_renderer'
+require 'pact/doc/markdown/index_renderer'
+
+module Pact
+  module Doc
+    module Markdown
+      class Generator < Pact::Doc::Generator
+
+        def initialize pact_dir, doc_dir
+          super(pact_dir, doc_dir,
+            consumer_contract_renderer: ConsumerContractRenderer,
+            doc_type: 'markdown',
+            file_extension: '.md',
+            index_renderer: IndexRenderer,
+            index_name: 'README')
+        end
+
+        def self.call pact_dir, doc_dir
+          new(pact_dir, doc_dir).call
+        end
+
+      end
+    end
+  end
+end

data/lib/pact/doc/markdown/index_renderer.rb

@@ -0,0 +1,41 @@
+module Pact
+  module Doc
+    module Markdown
+      class IndexRenderer
+
+        attr_reader :consumer_name
+        attr_reader :docs # Hash of pact title => file_name
+
+        def initialize consumer_name, docs
+          @consumer_name = consumer_name
+          @docs = docs
+        end
+
+        def self.call consumer_name, docs
+          new(consumer_name, docs).call
+        end
+
+        def call
+          title + "\n\n" + table_of_contents + "\n"
+        end
+
+        private
+
+        def table_of_contents
+          docs.collect do | title, file_name |
+            item title, file_name
+          end.join("\n")
+        end
+
+        def title
+          "### Pacts for #{consumer_name}"
+        end
+
+        def item title, file_name
+          "* [#{title}](#{file_name})"
+        end
+
+      end
+    end
+  end
+end

data/lib/pact/doc/markdown/interaction.erb

@@ -0,0 +1,14 @@
+<a name="<%= interaction.id %>"></a>
+<%= if interaction.has_provider_state?
+  "Given **#{interaction.provider_state}**, upon receiving"
+   else
+  "Upon receiving"
+   end
+%> **<%= interaction.description %>** from <%= interaction.consumer_name %>, with
+```json
+<%= interaction.request  %>
+```
+<%= interaction.provider_name %> will respond with:
+```json
+<%= interaction.response %>
+```

data/lib/pact/doc/markdown/interaction_renderer.rb

@@ -0,0 +1,38 @@
+require 'pact/doc/interaction_view_model'
+
+module Pact
+  module Doc
+    module Markdown
+      class InteractionRenderer
+
+        attr_reader :interaction
+
+        def initialize interaction, pact
+          @interaction = InteractionViewModel.new(interaction, pact)
+        end
+
+        def render_summary
+          suffix = interaction.has_provider_state? ? " given #{interaction.provider_state}" : ""
+          "* [#{interaction.description(true)}](##{interaction.id})#{suffix}\n\n"
+        end
+
+        def render_full_interaction
+          render('/interaction.erb')
+        end
+
+        def render template_file
+          ERB.new(template_string(template_file)).result(binding)
+        end
+
+        def template_string(template_file)
+          File.read( template_contents(template_file) )
+        end
+
+        def template_contents(template_file)
+          File.dirname(__FILE__) + template_file
+        end
+
+      end
+    end
+  end
+end

data/lib/pact/doc/sort_interactions.rb

@@ -0,0 +1,17 @@
+module Pact
+  module Doc
+    class SortInteractions
+
+      def self.call interactions
+        interactions.sort{|a, b| sortable_id(a) <=> sortable_id(b)}
+      end
+
+      private
+
+      def self.sortable_id interaction
+        "#{interaction.description.downcase} #{interaction.response['status']} #{(interaction.provider_state || '').downcase}"
+      end
+
+    end
+  end
+end

data/lib/pact/matchers/actual_type.rb

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

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

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

@@ -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