pact_broker 2.121.2 → 2.123.0

data/lib/pact/doc/generator.rb

@@ -1,82 +0,0 @@
-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_arg, target_dir_arg, consumer_contracts_arg| })
-      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

@@ -1,157 +0,0 @@
-require "pact/shared/active_support_support"
-require "pact/reification"
-require "cgi"
-require "pact/doc"
-
-module Pact
-  module Doc
-    class InteractionViewModel
-
-      include Pact::ActiveSupportSupport
-
-      MARKDOWN_BOLD_CHARACTERS = "**"
-
-      def initialize interaction, consumer_contract
-        @interaction = interaction
-        @consumer_contract = consumer_contract
-      end
-
-      def id
-        @id ||= begin
-          full_desc = if has_provider_state?
-                        "#{description} given #{interaction.provider_state}"
-                      else
-                        description
-                      end
-          CGI.escapeHTML(full_desc.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
-        markdown_escape @consumer_contract.consumer.name
-      end
-
-      def provider_name
-        markdown_escape @consumer_contract.provider.name
-      end
-
-      def has_provider_state?
-        @interaction.provider_state && !@interaction.provider_state.empty?
-      end
-
-      def provider_state start_of_sentence = false
-        markdown_escape apply_capitals(@interaction.provider_state.strip, start_of_sentence)
-      end
-
-      def formatted_provider_states mark_bold: false
-        bold_marker = mark_bold ? MARKDOWN_BOLD_CHARACTERS : ""
-
-        (@interaction.provider_states || []).map do |ps|
-          "#{bold_marker}" \
-          "#{markdown_escape(apply_capitals(ps.name.strip, false))}" \
-          "#{bold_marker}"
-        end.join(" and ")
-      end
-
-      def description start_of_sentence = false
-        return "" unless @interaction.description
-        markdown_escape apply_capitals(@interaction.description.strip, start_of_sentence)
-      end
-
-      def request
-        the_clean_request = clean_request
-        if the_clean_request == "ASYNC_REQUEST"
-          "ASYNC_REQUEST"
-        else  
-          fix_json_formatting JSON.pretty_generate(clean_request)
-        end
-      end
-
-      def response
-        fix_json_formatting JSON.pretty_generate(clean_response)
-      end
-
-      private
-
-      attr_reader :interaction, :consumer_contract
-
-      def clean_request
-        reified = Reification.from_term(interaction.request)
-        return "ASYNC_REQUEST" if reified[:method] == "FAKE_ASYNC_METHOD"
-
-        ordered = ordered_clean_hash(reified).tap do |h|
-          h[:body] = reified[:body] if reified[:body]
-        end
-
-        return ordered[:body].to_h.slice("contents", "metadata") if ordered[:method] == "FAKE_SYNC_METHOD"
-
-        ordered
-      end
-
-      def clean_response
-        raw = Reification.from_term(interaction.response)
-
-        case raw[:status]
-        when "FAKE_ASYNC_METHOD"
-          raw[:body] || {}
-        when "FAKE_SYNC_METHOD"
-          Array(raw.dig(:body, "contents")).map { |item| item.slice("contents", "metadata") }
-        else
-          ordered_clean_hash(raw)
-        end
-      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(source[key])
-          end
-        end
-      end
-
-      def value_is_an_empty_hash value
-        value.is_a?(Hash) && value.empty?
-      end
-
-      def ordered_keys
-        [:method, :path, :query, :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
-
-      def markdown_escape string
-        return nil unless string
-        string.gsub(Pact::Doc::MARKDOWN_SPECIAL_CHARS_REGEXP) { |char| "\\#{char}" }
-      end
-    end
-  end
-end

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

@@ -1,74 +0,0 @@
-require "pact/doc/markdown/interaction_renderer"
-require "pact/doc/sort_interactions"
-require "rack/utils"
-require "pact/doc"
-
-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 + interactions_title + full_interactions
-        end
-
-        private
-
-        attr_reader :consumer_contract
-
-        def title
-          "# A pact between #{consumer_name} and #{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_name} to #{provider_name}\n\n"
-        end
-
-        def interactions_title
-          "### Interactions\n\n"
-        end
-
-        def summaries
-          interaction_renderers.collect(&:render_summary).join
-        end
-
-        def full_interactions
-          interaction_renderers.collect(&:render_full_interaction).join
-        end
-
-        def sorted_interactions
-          SortInteractions.call(consumer_contract.interactions)
-        end
-
-        def consumer_name
-          h(markdown_escape consumer_contract.consumer.name)
-        end
-
-        def provider_name
-          h(markdown_escape consumer_contract.provider.name)
-        end
-
-        def markdown_escape string
-          return nil unless string
-          string.gsub(Pact::Doc::MARKDOWN_SPECIAL_CHARS_REGEXP) { |char| "\\#{char}" }
-        end
-
-        def h(text)
-          Rack::Utils.escape_html(text)
-        end
-      end
-    end
-  end
-end

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

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

@@ -1,40 +0,0 @@
-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_renderer.rb

@@ -1,51 +0,0 @@
-require "erb"
-require "pact/doc/interaction_view_model"
-require "rack/utils"
-
-module Pact
-  module Doc
-    module Markdown
-      class InteractionRenderer
-        attr_reader :interaction
-
-        def initialize interaction, pact
-          @interaction = InteractionViewModel.new(interaction, pact)
-        end
-
-        def render_summary
-          formatted_provider_states = h(interaction.formatted_provider_states)
-          suffix = formatted_provider_states.empty? ? "" : " given #{formatted_provider_states}"
-          "* [#{h(interaction.description(true))}](##{interaction.id})#{suffix}\n\n"
-        end
-
-        def render_full_interaction
-          if interaction.request == "ASYNC_REQUEST"
-            render("/interaction_async.erb")
-          else
-            render("/interaction.erb")
-          end
-        end
-
-        def render template_file
-          ERB.new(template_string(template_file)).result(binding)
-        end
-
-        # The template file is written with only ASCII range characters, so we
-        # can read as UTF-8. But rendered strings must have same encoding as
-        # script encoding because it will joined to strings which are produced by
-        # string literal.
-        def template_string(template_file)
-          File.read(template_contents(template_file), external_encoding: Encoding::UTF_8).force_encoding(__ENCODING__)
-        end
-
-        def template_contents(template_file)
-          File.dirname(__FILE__) + template_file
-        end
-
-        def h(text)
-          Rack::Utils.escape_html(text)
-        end
-      end
-    end
-  end
-end

data/lib/pact/doc/sort_interactions.rb

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

data/lib/pact/doc.rb

@@ -1,5 +0,0 @@
-module Pact
-  module Doc
-    MARKDOWN_SPECIAL_CHARS_REGEXP = /[\\`*_\[\](){}#+\-.!|]/
-  end
-end