hs-pact-support 1.17.1

data/lib/pact/matching_rules/extract.rb

@@ -0,0 +1,91 @@
+require 'pact/something_like'
+require 'pact/array_like'
+require 'pact/term'
+
+module Pact
+  module MatchingRules
+    class Extract
+
+      def self.call matchable
+        new(matchable).call
+      end
+
+      def initialize matchable
+        @matchable = matchable
+        @rules = Hash.new
+      end
+
+      def call
+        recurse matchable, "$", nil
+        rules
+      end
+
+      private
+
+      attr_reader :matchable, :rules
+
+      def recurse object, path, match_type
+        case object
+        when Hash then recurse_hash(object, path, match_type)
+        when Array then recurse_array(object, path, match_type)
+        when Pact::SomethingLike then handle_something_like(object, path, match_type)
+        when Pact::ArrayLike then handle_array_like(object, path, match_type)
+        when Pact::Term then record_regex_rule object, path
+        when Pact::QueryString then recurse(object.query, path, match_type)
+        when Pact::QueryHash then recurse_hash(object.query, path, match_type)
+        end
+      end
+
+      def recurse_hash hash, path, match_type
+        hash.each do | (key, value) |
+          recurse value, "#{path}#{next_path_part(key)}", match_type
+        end
+      end
+
+      def recurse_array new_array, path, match_type
+        new_array.each_with_index do | value, index |
+          recurse value, "#{path}[#{index}]", match_type
+        end
+      end
+
+      def handle_something_like something_like, path, match_type
+        record_match_type_rule path, "type"
+        recurse something_like.contents, path, "type"
+      end
+
+      def handle_array_like array_like, path, match_type
+        record_rule "#{path}", 'min' => array_like.min
+        record_match_type_rule "#{path}[*].*", 'type'
+        recurse array_like.contents, "#{path}[*]", :array_like
+      end
+
+      def record_rule path, rule
+        rules[path] ||= {}
+        rules[path] = rules[path].merge(rule)
+      end
+
+      def record_regex_rule term, path
+        rules[path] ||= {}
+        rules[path]['match'] = 'regex'
+        rules[path]['regex'] = term.matcher.inspect[1..-2]
+      end
+
+      def record_match_type_rule path, match_type
+        unless match_type == :array_like || match_type.nil?
+          rules[path] ||= {}
+          rules[path]['match'] = match_type
+        end
+      end
+
+      # Beth: there's a potential bug if the key contains a dot and a single quote.
+      # Not sure what to do then.
+      def next_path_part key
+        if key.to_s.include?('.')
+          "['#{key}']"
+        else
+          ".#{key}"
+        end
+      end
+    end
+  end
+end

data/lib/pact/matching_rules/jsonpath.rb

@@ -0,0 +1,58 @@
+require 'strscan'
+
+# Ripped with appreciation from Joshua Hull's useful JsonPath gem
+# https://github.com/joshbuddy/jsonpath/blob/792ff9a928998f4252692cd3c1ba378ed931a5aa/lib/jsonpath.rb
+# Only including the code that Pact needs, to reduce dependencies and potential gem version clashes.
+
+module Pact
+  module MatchingRules
+    class JsonPath
+
+      attr_reader :path
+
+      def initialize(path)
+        scanner = StringScanner.new(path)
+        @path = []
+        while not scanner.eos?
+          if token = scanner.scan(/\$/)
+            @path << token
+          elsif token = scanner.scan(/@/)
+            @path << token
+          elsif token = scanner.scan(/[:a-zA-Z0-9_-]+/)
+            @path << "['#{token}']"
+          elsif token = scanner.scan(/'(.*?)'/)
+            @path << "[#{token}]"
+          elsif token = scanner.scan(/\[/)
+            count = 1
+            while !count.zero?
+              if t = scanner.scan(/\[/)
+                token << t
+                count += 1
+              elsif t = scanner.scan(/\]/)
+                token << t
+                count -= 1
+              elsif t = scanner.scan(/[^\[\]]*/)
+                token << t
+              end
+            end
+            @path << token
+          elsif token = scanner.scan(/\.\./)
+            @path << token
+          elsif scanner.scan(/\./)
+            nil
+          elsif token = scanner.scan(/\*/)
+            @path << token
+          elsif token = scanner.scan(/[><=] \d+/)
+            @path.last << token
+          elsif token = scanner.scan(/./)
+            @path.last << token
+          end
+        end
+      end
+
+      def to_s
+        path.join
+      end
+    end
+  end
+end

data/lib/pact/matching_rules/merge.rb

@@ -0,0 +1,125 @@
+require 'pact/array_like'
+require 'pact/matching_rules/jsonpath'
+
+module Pact
+  module MatchingRules
+    class Merge
+
+      def self.call expected, matching_rules, root_path = '$'
+        new(expected, matching_rules, root_path).call
+      end
+
+      def initialize expected, matching_rules, root_path
+        @expected = expected
+        @matching_rules = standardise_paths(matching_rules)
+        @root_path = JsonPath.new(root_path).to_s
+        @used_rules = []
+      end
+
+      def call
+        return @expected if @matching_rules.nil? || @matching_rules.empty?
+        recurse(@expected, @root_path).tap { log_ignored_rules }
+      end
+
+      private
+
+      def standardise_paths matching_rules
+        return matching_rules if matching_rules.nil? || matching_rules.empty?
+        matching_rules.each_with_object({}) do | (path, rule), new_matching_rules |
+          new_matching_rules[JsonPath.new(path).to_s] = rule
+        end
+      end
+
+      def recurse expected, path
+        recursed = case expected
+        when Hash then recurse_hash(expected, path)
+        when Array then recurse_array(expected, path)
+        else
+          expected
+        end
+
+        wrap(recursed, path)
+      end
+
+      def recurse_hash hash, path
+        recursed =  hash.each_with_object({}) do | (k, v), new_hash |
+          new_path = path + "['#{k}']"
+          new_hash[k] = recurse(v, new_path)
+        end
+      end
+
+      def recurse_array array, path
+        parent_match_rule = find_rule(path, 'match')
+        log_used_rule(path, 'match', parent_match_rule) if parent_match_rule
+
+        array_like_children_path = "#{path}[*]*"
+        children_match_rule = find_rule(array_like_children_path, 'match')
+        log_used_rule(array_like_children_path, 'match', children_match_rule) if children_match_rule
+
+        min = find_rule(path, 'min')
+        log_used_rule(path, 'min', min) if min
+
+        if min && (children_match_rule == 'type' || (children_match_rule.nil? && parent_match_rule == 'type'))
+          warn_when_not_one_example_item(array, path)
+          Pact::ArrayLike.new(recurse(array.first, "#{path}[*]"), min: min)
+        else
+          new_array = []
+          array.each_with_index do | item, index |
+            new_path = path + "[#{index}]"
+            new_array << recurse(item, new_path)
+          end
+          new_array
+        end
+      end
+
+      def warn_when_not_one_example_item array, path
+        unless array.size == 1
+          Pact.configuration.error_stream.puts "WARN: Only the first item will be used to match the items in the array at #{path}"
+        end
+      end
+
+      def wrap object, path
+        if find_rule(path, 'match') == 'type' && !find_rule(path, 'min')
+          handle_match_type(object, path)
+        elsif find_rule(path, 'regex')
+          handle_regex(object, path)
+        else
+          object
+        end
+      end
+
+      def handle_match_type object, path
+        log_used_rule(path, 'match', 'type')
+        Pact::SomethingLike.new(object)
+      end
+
+      def handle_regex object, path
+        regex = find_rule(path, 'regex')
+        log_used_rule(path, 'match', 'regex') # assumed to be present
+        log_used_rule(path, 'regex', regex)
+        Pact::Term.new(generate: object, matcher: Regexp.new(regex))
+      end
+
+      def log_ignored_rules
+        dup_rules = @matching_rules.dup
+        @used_rules.each do | (path, key, value) |
+          dup_rules[path].delete(key) if dup_rules[path][key] == value
+        end
+
+        if dup_rules.any?
+          dup_rules.each do | path, rules |
+            $stderr.puts "WARN: Ignoring unsupported matching rules #{rules} for path #{path}" if rules.any?
+          end
+        end
+      end
+
+      def find_rule(path, key)
+        @matching_rules[path] && @matching_rules[path][key]
+      end
+
+      def log_used_rule path, key, value
+        @used_rules << [path, key, value]
+      end
+    end
+  end
+end

data/lib/pact/matching_rules/v3/extract.rb

@@ -0,0 +1,94 @@
+require 'pact/something_like'
+require 'pact/array_like'
+require 'pact/term'
+
+module Pact
+  module MatchingRules::V3
+    class Extract
+
+      def self.call matchable
+        new(matchable).call
+      end
+
+      def initialize matchable
+        @matchable = matchable
+        @rules = Hash.new
+      end
+
+      def call
+        recurse matchable, "$", nil
+        rules
+      end
+
+      private
+
+      attr_reader :matchable, :rules
+
+      def recurse object, path, match_type
+        case object
+        when Hash then recurse_hash(object, path, match_type)
+        when Array then recurse_array(object, path, match_type)
+        when Pact::SomethingLike then handle_something_like(object, path, match_type)
+        when Pact::ArrayLike then handle_array_like(object, path, match_type)
+        when Pact::Term then record_regex_rule object, path
+        when Pact::QueryString then recurse(object.query, path, match_type)
+        when Pact::QueryHash then recurse_hash(object.query, path, match_type)
+        end
+      end
+
+      def recurse_hash hash, path, match_type
+        hash.each do | (key, value) |
+          recurse value, "#{path}#{next_path_part(key)}", match_type
+        end
+      end
+
+      def recurse_array new_array, path, match_type
+        new_array.each_with_index do | value, index |
+          recurse value, "#{path}[#{index}]", match_type
+        end
+      end
+
+      def handle_something_like something_like, path, match_type
+        record_match_type_rule path, "type"
+        recurse something_like.contents, path, "type"
+      end
+
+      def handle_array_like array_like, path, match_type
+        record_rule "#{path}", 'min' => array_like.min
+        record_match_type_rule "#{path}[*].*", 'type'
+        recurse array_like.contents, "#{path}[*]", :array_like
+      end
+
+      def record_rule path, rule
+        rules[path] ||= {}
+        rules[path]['matchers'] ||= []
+        rules[path]['matchers'] << rule
+      end
+
+      def record_regex_rule term, path
+        rules[path] ||= {}
+        rules[path]['matchers'] ||= []
+        rule = { 'match' => 'regex', 'regex' => term.matcher.inspect[1..-2]}
+        rules[path]['matchers'] << rule
+      end
+
+      def record_match_type_rule path, match_type
+        unless match_type == :array_like || match_type.nil?
+          rules[path] ||= {}
+          rules[path]['matchers'] ||= []
+          rules[path]['matchers'] << { 'match' => match_type }
+        end
+      end
+
+      # Beth: there's a potential bug if the key contains a dot and a single quote.
+      # Not sure what to do then.
+      def next_path_part key
+        if key.to_s.include?('.')
+          "['#{key}']"
+        else
+          ".#{key}"
+        end
+      end
+    end
+  end
+end

data/lib/pact/matching_rules/v3/merge.rb

@@ -0,0 +1,141 @@
+require 'pact/array_like'
+require 'pact/matching_rules/jsonpath'
+
+module Pact
+  module MatchingRules
+    module V3
+      class Merge
+
+        def self.call expected, matching_rules, root_path = '$'
+          new(expected, matching_rules, root_path).call
+        end
+
+        def initialize expected, matching_rules, root_path
+          @expected = expected
+          @matching_rules = standardise_paths(matching_rules)
+          @root_path = JsonPath.new(root_path).to_s
+        end
+
+        def call
+          return @expected if @matching_rules.nil? || @matching_rules.empty?
+          recurse(@expected, @root_path).tap { log_ignored_rules }
+        end
+
+        private
+
+        def standardise_paths matching_rules
+          return matching_rules if matching_rules.nil? || matching_rules.empty?
+          matching_rules.each_with_object({}) do | (path, rules), new_matching_rules |
+            new_matching_rules[JsonPath.new(path).to_s] = Marshal.load(Marshal.dump(rules)) # simplest way to deep clone
+          end
+        end
+
+        def recurse expected, path
+          recursed = case expected
+          when Hash then recurse_hash(expected, path)
+          when Array then recurse_array(expected, path)
+          else
+            expected
+          end
+          wrap(recursed, path)
+        end
+
+        def recurse_hash hash, path
+          hash.each_with_object({}) do | (k, v), new_hash |
+            new_path = path + "['#{k}']"
+            new_hash[k] = recurse(v, new_path)
+          end
+        end
+
+        def recurse_array array, path
+          # This assumes there is only one rule! TODO make this find the appropriate rule.
+          parent_match_rule = @matching_rules[path]['matchers'].first['match'] rescue nil
+          array_like_children_path = "#{path}[*]*"
+          children_match_rule = @matching_rules[array_like_children_path]['matchers'].first['match'] rescue nil
+          min = @matching_rules[path]['matchers'].first['min'] rescue nil
+
+          if min && children_match_rule == 'type'
+            @matching_rules[path]['matchers'].first.delete('min')
+            @matching_rules[array_like_children_path]['matchers'].first.delete('match')
+            warn_when_not_one_example_item(array, path)
+            Pact::ArrayLike.new(recurse(array.first, "#{path}[*]"), min: min)
+          elsif min && parent_match_rule == 'type'
+            @matching_rules[path]['matchers'].first.delete('min')
+            @matching_rules[path]['matchers'].first.delete('match')
+            warn_when_not_one_example_item(array, path)
+            Pact::ArrayLike.new(recurse(array.first, "#{path}[*]"), min: min)
+          else
+            new_array = []
+            array.each_with_index do | item, index |
+              new_path = path + "[#{index}]"
+              new_array << recurse(item, new_path)
+            end
+            new_array
+          end
+        end
+
+        def warn_when_not_one_example_item array, path
+          unless array.size == 1
+            Pact.configuration.error_stream.puts "WARN: Only the first item will be used to match the items in the array at #{path}"
+          end
+        end
+
+        def wrap object, path
+          rules = @matching_rules[path] && @matching_rules[path]['matchers'] && @matching_rules[path]['matchers'].first
+          array_rules = @matching_rules["#{path}[*]*"] && @matching_rules["#{path}[*]*"]['matchers'] && @matching_rules["#{path}[*]*"]['matchers'].first
+          return object unless rules || array_rules
+
+          if rules['match'] == 'type' && !rules.has_key?('min')
+            handle_match_type(object, path, rules)
+          elsif rules['regex']
+            handle_regex(object, path, rules)
+          else
+            object
+          end
+        end
+
+        def handle_match_type object, path, rules
+          rules.delete('match')
+          Pact::SomethingLike.new(object)
+        end
+
+        def handle_regex object, path, rules
+          rules.delete('match')
+          regex = rules.delete('regex')
+          Pact::Term.new(generate: object, matcher: Regexp.new(regex))
+        end
+
+        def log_ignored_rules
+          @matching_rules.each do | jsonpath, rules_hash |
+            rules_array = rules_hash["matchers"]
+            if rules_array
+              ((rules_array.length - 1)..0).each do | index |
+                rules_array.delete_at(index) if rules_array[index].empty?
+              end
+            end
+          end
+
+          if @matching_rules.any?
+            @matching_rules.each do | path, rules_hash |
+              rules_hash.each do | key, value |
+                $stderr.puts "WARN: Ignoring unsupported #{key} #{value} for path #{path}" if value_present?(value)
+              end
+            end
+          end
+        end
+
+        def find_rule(path, key)
+          @matching_rules[path] && @matching_rules[path][key]
+        end
+
+        def log_used_rule path, key, value
+          @used_rules << [path, key, value]
+        end
+
+        def value_present? value
+          value.respond_to?(:any?) ? value.any? : true
+        end
+      end
+    end
+  end
+end

data/lib/pact/matching_rules.rb

@@ -0,0 +1,30 @@
+require 'pact/matching_rules/extract'
+require 'pact/matching_rules/v3/extract'
+require 'pact/matching_rules/merge'
+require 'pact/matching_rules/v3/merge'
+
+module Pact
+  module MatchingRules
+
+    # @api public Used by pact-mock_service
+    def self.extract object_graph, options = {}
+      pact_specification_version = options[:pact_specification_version] || Pact::SpecificationVersion::NIL_VERSION
+      case pact_specification_version.major
+      when nil, 0, 1, 2
+        Extract.(object_graph)
+      else
+        V3::Extract.(object_graph)
+      end
+    end
+
+    def self.merge object_graph, matching_rules, options = {}
+      pact_specification_version = options[:pact_specification_version] || Pact::SpecificationVersion::NIL_VERSION
+      case pact_specification_version.major
+      when nil, 0, 1, 2
+        Merge.(object_graph, matching_rules)
+      else
+        V3::Merge.(object_graph, matching_rules)
+      end
+    end
+  end
+end

data/lib/pact/reification.rb

@@ -0,0 +1,56 @@
+require 'expgen'
+require 'pact/term'
+require 'pact/something_like'
+require 'pact/array_like'
+require 'pact/shared/request'
+require 'pact/consumer_contract/query_hash'
+require 'pact/consumer_contract/query_string'
+require 'pact/consumer_contract/string_with_matching_rules'
+
+module Pact
+  module Reification
+    include ActiveSupportSupport
+
+    def self.from_term(term)
+      case term
+      when Pact::Term, Pact::SomethingLike, Pact::ArrayLike
+        from_term(term.generate)
+      when Regexp
+        from_term(Expgen.gen(term))
+      when Hash
+        term.inject({}) do |mem, (key,t)|
+          mem[key] = from_term(t)
+          mem
+        end
+      when Array
+        term.map{ |t| from_term(t)}
+      when Pact::Request::Base
+        from_term(term.to_hash)
+      when Pact::QueryString
+        from_term(term.query)
+      when Pact::QueryHash
+        if term.original_string
+          term.original_string
+        else
+          from_term(term.query).map { |k, v|
+            if v.nil?
+              k
+            elsif v.is_a?(Array) #For cases where there are multiple instance of the same parameter
+              v.map { |x| "#{k}=#{escape(x)}"}.join('&')
+            else
+              "#{k}=#{escape(v)}"
+            end
+          }.join('&')
+        end
+      when Pact::StringWithMatchingRules
+        String.new(term)
+      else
+        term
+      end
+    end
+
+    def self.escape(str)
+      URI.encode_www_form_component(str)
+    end
+  end
+end

data/lib/pact/rspec.rb

@@ -0,0 +1,51 @@
+# 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
+      defined?(::RSpec) && ::RSpec::Core::Formatters.respond_to?(:register)
+    end
+
+    def self.is_rspec_2
+      defined?(::RSpec) && !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