pact-v2 2.0.0.pre.preview1

data/lib/pact/v2/matchers/v3/date.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Pact
+  module V2
+    module Matchers
+      module V3
+        class Date < Pact::V2::Matchers::Base
+          def initialize(format, template)
+            raise MatcherInitializationError, "#{self.class}: #{format} should be an instance of String" unless template.is_a?(String)
+            raise MatcherInitializationError, "#{self.class}: #{template} should be an instance of String" unless template.is_a?(String)
+
+            super(spec_version: Pact::V2::Matchers::PACT_SPEC_V3, kind: "date", template: template, opts: {format: format})
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pact/v2/matchers/v3/date_time.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Pact
+  module V2
+    module Matchers
+      module V3
+        class DateTime < Pact::V2::Matchers::Base
+          def initialize(format, template)
+            raise MatcherInitializationError, "#{self.class}: #{format} should be an instance of String" unless template.is_a?(String)
+            raise MatcherInitializationError, "#{self.class}: #{template} should be an instance of String" unless template.is_a?(String)
+
+            super(spec_version: Pact::V2::Matchers::PACT_SPEC_V3, kind: "datetime", template: template, opts: {format: format})
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pact/v2/matchers/v3/decimal.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Pact
+  module V2
+    module Matchers
+      module V3
+        class Decimal < Pact::V2::Matchers::Base
+          def initialize(template)
+            raise MatcherInitializationError, "#{self.class}: #{template} should be an instance of Float" unless template.is_a?(Float)
+
+            super(spec_version: Pact::V2::Matchers::PACT_SPEC_V3, kind: "decimal", template: template)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pact/v2/matchers/v3/each.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Pact
+  module V2
+    module Matchers
+      module V3
+        class Each < Pact::V2::Matchers::Base
+          def initialize(template, min)
+            raise MatcherInitializationError, "#{self.class}: #{min} should be greater than 0" if min.present? && min < 1
+
+            min_array_size = min.presence || 1
+            val = template.is_a?(Array) ? template : [template] * min_array_size
+
+            raise MatcherInitializationError, "#{self.class}: #{min} is invalid: template size is #{val.size}" if min_array_size != val.size
+
+            super(
+              spec_version: Pact::V2::Matchers::PACT_SPEC_V3,
+              kind: "type",
+              template: val,
+              opts: {min: min_array_size})
+          end
+
+          def as_plugin
+            if @template.first.is_a?(Hash)
+              return {
+                "pact:match" => "eachValue(matching($'SAMPLE'))",
+                "SAMPLE" => serialize!(@template.first.deep_dup, :plugin)
+              }
+            end
+
+            params = @opts.except(:min).values.map { |v| format_primitive(v) }.join(",")
+            value = format_primitive(@template.first)
+
+            return "eachValue(matching(#{@kind}, #{params}, #{value}))" if params.present?
+
+            "eachValue(matching(#{@kind}, #{value}))"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pact/v2/matchers/v3/include.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Pact
+  module V2
+    module Matchers
+      module V3
+        class Include < Pact::V2::Matchers::Base
+          def initialize(template)
+            raise MatcherInitializationError, "#{self.class}: #{template} should be an instance of String" unless template.is_a?(String)
+
+            super(spec_version: Pact::V2::Matchers::PACT_SPEC_V3, kind: "include", template: template)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pact/v2/matchers/v3/integer.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Pact
+  module V2
+    module Matchers
+      module V3
+        class Integer < Pact::V2::Matchers::Base
+          def initialize(template)
+            raise MatcherInitializationError, "#{self.class}: #{template} should be an instance of Integer" unless template.is_a?(::Integer)
+
+            super(spec_version: Pact::V2::Matchers::PACT_SPEC_V3, kind: "integer", template: template)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pact/v2/matchers/v3/number.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Pact
+  module V2
+    module Matchers
+      module V3
+        class Number < Pact::V2::Matchers::Base
+          def initialize(template)
+            raise MatcherInitializationError, "#{self.class}: #{template} should be an instance of Numeric" unless template.is_a?(Numeric)
+
+            super(spec_version: Pact::V2::Matchers::PACT_SPEC_V3, kind: "number", template: template)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pact/v2/matchers/v3/time.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Pact
+  module V2
+    module Matchers
+      module V3
+        class Time < Pact::V2::Matchers::Base
+          def initialize(format, template)
+            raise MatcherInitializationError, "#{self.class}: #{format} should be an instance of String" unless template.is_a?(String)
+            raise MatcherInitializationError, "#{self.class}: #{template} should be an instance of String" unless template.is_a?(String)
+
+            super(spec_version: Pact::V2::Matchers::PACT_SPEC_V3, kind: "time", template: template, opts: {format: format})
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pact/v2/matchers/v4/each_key.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Pact
+  module V2
+    module Matchers
+      module V4
+        class EachKey < Pact::V2::Matchers::Base
+          def initialize(key_matchers, template)
+            raise MatcherInitializationError, "#{self.class}: #{template} should be a Hash" unless template.is_a?(Hash)
+            raise MatcherInitializationError, "#{self.class}: #{key_matchers} should be an Array" unless key_matchers.is_a?(Array)
+            raise MatcherInitializationError, "#{self.class}: #{key_matchers} should be instances of Pact::V2::Matchers::Base" unless key_matchers.all?(Pact::V2::Matchers::Base)
+            raise MatcherInitializationError, "#{self.class}: #{key_matchers} size should be greater than 0" unless key_matchers.size > 0
+
+            super(spec_version: Pact::V2::Matchers::PACT_SPEC_V4, kind: "each-key", template: template, opts: {rules: key_matchers})
+          end
+
+          def as_plugin
+            @opts[:rules].map do |matcher|
+              "eachKey(#{matcher.as_plugin})"
+            end.join(", ")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pact/v2/matchers/v4/each_key_value.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Pact
+  module V2
+    module Matchers
+      module V4
+        class EachKeyValue < Pact::V2::Matchers::Base
+          def initialize(key_matchers, template)
+            raise MatcherInitializationError, "#{self.class}: #{template} should be a Hash" unless template.is_a?(Hash)
+            raise MatcherInitializationError, "#{self.class}: #{key_matchers} should be an Array" unless key_matchers.is_a?(Array)
+            raise MatcherInitializationError, "#{self.class}: #{key_matchers} should be instances of Pact::V2::Matchers::Base" unless key_matchers.all?(Pact::V2::Matchers::Base)
+
+            super(
+              spec_version: Pact::V2::Matchers::PACT_SPEC_V4,
+              kind: [
+                EachKey.new(key_matchers, {}),
+                EachValue.new([Pact::V2::Matchers::V2::Type.new("")], {})
+              ],
+              template: template
+            )
+
+            @key_matchers = key_matchers
+          end
+
+          def as_plugin
+            raise MatcherInitializationError, "#{self.class}: each-key-value is not supported in plugin syntax. Use each / each_key / each_value matchers instead"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pact/v2/matchers/v4/each_value.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Pact
+  module V2
+    module Matchers
+      module V4
+        class EachValue < Pact::V2::Matchers::Base
+          def initialize(value_matchers, template)
+            # raise MatcherInitializationError, "#{self.class}: #{template} should be a Hash" unless template.is_a?(Hash)
+            raise MatcherInitializationError, "#{self.class}: #{value_matchers} should be an Array" unless value_matchers.is_a?(Array)
+            raise MatcherInitializationError, "#{self.class}: #{value_matchers} should be instances of Pact::V2::Matchers::Base" unless value_matchers.all?(Pact::V2::Matchers::Base)
+            raise MatcherInitializationError, "#{self.class}: #{value_matchers} size should be greater than 0" unless value_matchers.size > 0
+
+            super(spec_version: Pact::V2::Matchers::PACT_SPEC_V4, kind: "each-value", template: template, opts: {rules: value_matchers})
+          end
+
+          def as_plugin
+            if @template.is_a?(Hash)
+              return {
+                "pact:match" => "eachValue(matching($'SAMPLE'))",
+                "SAMPLE" => serialize!(@template.deep_dup, :plugin)
+              }
+            end
+
+            @opts[:rules].map do |matcher|
+              "eachValue(#{matcher.as_plugin})"
+            end.join(", ")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pact/v2/matchers/v4/not_empty.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Pact
+  module V2
+    module Matchers
+      module V4
+        class NotEmpty < Pact::V2::Matchers::Base
+          def initialize(template)
+            raise MatcherInitializationError, "#{self.class}: #{template} should not be empty" if template.blank?
+
+            super(spec_version: Pact::V2::Matchers::PACT_SPEC_V4, kind: "time", template: template)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pact/v2/matchers.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module Pact
+  module V2
+    module Matchers
+      PACT_SPEC_V1 = 1
+      PACT_SPEC_V2 = 2
+      PACT_SPEC_V3 = 3
+      PACT_SPEC_V4 = 4
+
+      ANY_STRING_REGEX = /.*/
+      UUID_REGEX = /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/i
+
+      # simplified
+      ISO8601_REGEX = /\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)*(.\d{2}:\d{2})*/i
+
+      def match_exactly(arg)
+        V1::Equality.new(arg)
+      end
+
+      def match_type_of(arg)
+        V2::Type.new(arg)
+      end
+
+      def match_include(arg)
+        V3::Include.new(arg)
+      end
+
+      def match_any_string(sample = "any")
+        V2::Regex.new(ANY_STRING_REGEX, sample)
+      end
+
+      def match_any_integer(sample = 10)
+        V3::Integer.new(sample)
+      end
+
+      def match_any_decimal(sample = 10.0)
+        V3::Decimal.new(sample)
+      end
+
+      def match_any_number(sample = 10.0)
+        V3::Number.new(sample)
+      end
+
+      def match_any_boolean(sample = true)
+        V3::Boolean.new(sample)
+      end
+
+      def match_uuid(sample = "e1d01e04-3a2b-4eed-a4fb-54f5cd257338")
+        V2::Regex.new(UUID_REGEX, sample)
+      end
+
+      def match_regex(regex, sample)
+        V2::Regex.new(regex, sample)
+      end
+
+      def match_datetime(format, sample)
+        V3::DateTime.new(format, sample)
+      end
+
+      def match_iso8601(sample = "2024-08-12T12:25:00.243118+03:00")
+        V2::Regex.new(ISO8601_REGEX, sample)
+      end
+
+      def match_date(format, sample)
+        V3::Date.new(format, sample)
+      end
+
+      def match_time(format, sample)
+        V3::Time.new(format, sample)
+      end
+
+      def match_each(template, min = nil)
+        V3::Each.new(template, min)
+      end
+
+      def match_each_regex(regex, sample)
+        match_each_value(sample, match_regex(regex, sample))
+      end
+
+      def match_each_key(template, key_matchers)
+        V4::EachKey.new(key_matchers.is_a?(Array) ? key_matchers : [key_matchers], template)
+      end
+
+      def match_each_value(template, value_matchers = V2::Type.new(""))
+        V4::EachValue.new(value_matchers.is_a?(Array) ? value_matchers : [value_matchers], template)
+      end
+
+      def match_each_kv(template, key_matchers)
+        V4::EachKeyValue.new(key_matchers.is_a?(Array) ? key_matchers : [key_matchers], template)
+      end
+    end
+  end
+end

data/lib/pact/v2/native/blocking_verifier.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "ffi"
+require "pact/ffi/verifier"
+
+module Pact
+  module V2
+    module Native
+      module BlockingVerifier
+        extend FFI::Library
+        ffi_lib DetectOS.get_bin_path
+
+        attach_function :execute, :pactffi_verifier_execute, %i[pointer], :int32, blocking: true
+      end
+    end
+  end
+end

data/lib/pact/v2/native/logger.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "pact/ffi/logger"
+
+module Pact
+  module V2
+    module Native
+      module Logger
+        LOG_LEVELS = {
+          off: PactFfi::FfiLogLevelFilter["LOG_LEVEL_OFF"],
+          error: PactFfi::FfiLogLevelFilter["LOG_LEVEL_ERROR"],
+          warn: PactFfi::FfiLogLevelFilter["LOG_LEVEL_WARN"],
+          info: PactFfi::FfiLogLevelFilter["LOG_LEVEL_INFO"],
+          debug: PactFfi::FfiLogLevelFilter["LOG_LEVEL_DEBUG"],
+          trace: PactFfi::FfiLogLevelFilter["LOG_LEVEL_TRACE"]
+        }.freeze
+
+        def self.log_to_stdout(log_level)
+          raise "invalid log level for PactFfi::FfiLogLevelFilter" unless LOG_LEVELS.key?(log_level)
+          PactFfi::Logger.log_to_stdout(LOG_LEVELS[log_level])
+        end
+      end
+    end
+  end
+end

data/lib/pact/v2/provider/async_message_verifier.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "pact/ffi/verifier"
+require "pact/v2/native/logger"
+
+module Pact
+  module V2
+    module Provider
+      class AsyncMessageVerifier < BaseVerifier
+        PROVIDER_TRANSPORT_TYPE = "message"
+
+        def initialize(pact_config, mixed_config = nil)
+          super
+
+          raise ArgumentError, "pact_config must be an instance of Pact::V2::Provider::PactConfig::Message" unless pact_config.is_a?(::Pact::V2::Provider::PactConfig::Async)
+        end
+
+        private
+
+        def add_provider_transport(pact_handle)
+          setup_uri = URI(@pact_config.message_setup_url)
+          PactFfi::Verifier.add_provider_transport(pact_handle, PROVIDER_TRANSPORT_TYPE, setup_uri.port, setup_uri.path, "")
+        end
+
+      end
+    end
+  end
+end