ory-kratos-client 0.7.6.alpha7 → 0.8.0.alpha2

data/vendor/bundle/ruby/2.5.0/gems/{ethon-0.14.0 → ethon-0.15.0}/lib/ethon/easy/operations.rb

@@ -4,20 +4,6 @@ module Ethon
     # This module contains the logic to prepare and perform
     # an easy.
     module Operations
-      
-      class PointerHelper
-        class<<self
-          def synchronize( &block )
-            (@mutex ||= Mutex.new).synchronize( &block )
-          end
-
-          def release( pointer )
-            synchronize { Curl.easy_cleanup pointer }
-          end
-        end
-        synchronize{}
-      end
-
       # Returns a pointer to the curl easy handle.
       #
       # @example Return the handle.
@@ -25,7 +11,7 @@ module Ethon
       #
       # @return [ FFI::Pointer ] A pointer to the curl easy handle.
       def handle
-        @handle ||= FFI::AutoPointer.new(Curl.easy_init, PointerHelper.method(:release) )
+        @handle ||= FFI::AutoPointer.new(Curl.easy_init, Curl.method(:easy_cleanup))
       end
 
       # Sets a pointer to the curl easy handle.

data/vendor/bundle/ruby/2.5.0/gems/{ethon-0.14.0 → ethon-0.15.0}/lib/ethon/multi/operations.rb

@@ -24,12 +24,16 @@ module Ethon
       #
       # @return [ void ]
       def init_vars
-        @timeout = ::FFI::MemoryPointer.new(:long)
-        @timeval = Curl::Timeval.new
-        @fd_read = Curl::FDSet.new
-        @fd_write = Curl::FDSet.new
-        @fd_excep = Curl::FDSet.new
-        @max_fd = ::FFI::MemoryPointer.new(:int)
+        if @execution_mode == :perform
+          @timeout = ::FFI::MemoryPointer.new(:long)
+          @timeval = Curl::Timeval.new
+          @fd_read = Curl::FDSet.new
+          @fd_write = Curl::FDSet.new
+          @fd_excep = Curl::FDSet.new
+          @max_fd = ::FFI::MemoryPointer.new(:int)
+        elsif @execution_mode == :socket_action
+          @running_count_pointer = FFI::MemoryPointer.new(:int)
+        end
       end
 
       # Perform multi.
@@ -39,6 +43,8 @@ module Ethon
       # @example Perform multi.
       #   multi.perform
       def perform
+        ensure_execution_mode(:perform)
+
         Ethon.logger.debug(STARTED_MULTI)
         while ongoing?
           run
@@ -67,9 +73,38 @@ module Ethon
         )
       end
 
-      private
+      # Continue execution with an external IO loop.
+      #
+      # @example When no sockets are ready yet, or to begin.
+      #   multi.socket_action
+      #
+      # @example When a socket is readable
+      #   multi.socket_action(io_object, [:in])
+      #
+      # @example When a socket is readable and writable
+      #   multi.socket_action(io_object, [:in, :out])
+      #
+      # @return [ Symbol ] The Curl.multi_socket_action return code.
+      def socket_action(io = nil, readiness = 0)
+        ensure_execution_mode(:socket_action)
+
+        fd = if io.nil?
+          ::Ethon::Curl::SOCKET_TIMEOUT
+        elsif io.is_a?(Integer)
+          io
+        else
+          io.fileno
+        end
+
+        code = Curl.multi_socket_action(handle, fd, readiness, @running_count_pointer)
+        @running_count = @running_count_pointer.read_int
 
-      # Return wether the multi still requests or not.
+        check
+
+        code
+      end
+
+      # Return whether the multi still contains requests or not.
       #
       # @example Return if ongoing.
       #   multi.ongoing?
@@ -79,6 +114,8 @@ module Ethon
         easy_handles.size > 0 || (!defined?(@running_count) || running_count > 0)
       end
 
+      private
+
       # Get timeout.
       #
       # @example Get timeout.

data/vendor/bundle/ruby/2.5.0/gems/{ethon-0.14.0 → ethon-0.15.0}/lib/ethon/multi.rb

@@ -74,10 +74,21 @@ module Ethon
     # is 1 will not be treated as unlimited. Instead it will open only 1 
     # connection and try to pipeline on it.
     # (Added in 7.30.0)
+    # @option options :execution_mode [Boolean]
+    #  Either :perform (default) or :socket_action, specifies the usage
+    #  method that will be used on this multi object. The default :perform
+    #  mode provides a #perform function that uses curl_multi_perform
+    #  behind the scenes to automatically continue execution until all
+    #  requests have completed. The :socket_action mode provides an API
+    #  that allows the {Multi} object to be integrated into an external
+    #  IO loop, by calling #socket_action and responding to the 
+    #  socketfunction and timerfunction callbacks, using the underlying
+    #  curl_multi_socket_action semantics.
     #
     # @return [ Multi ] The new multi.
     def initialize(options = {})
       Curl.init
+      @execution_mode = options.delete(:execution_mode) || :perform
       set_attributes(options)
       init_vars
     end
@@ -100,5 +111,16 @@ module Ethon
         method("#{key}=").call(value)
       end
     end
+
+    private
+
+    # Internal function to gate functions to a specific execution mode
+    #
+    # @raise ArgumentError
+    #
+    # @api private
+    def ensure_execution_mode(expected_mode)
+      raise ArgumentError, "Expected the Multi to be in #{expected_mode} but it was in #{@execution_mode}" if expected_mode != @execution_mode
+    end
   end
 end

data/vendor/bundle/ruby/2.5.0/gems/{ethon-0.14.0 → ethon-0.15.0}/lib/ethon/version.rb

@@ -2,5 +2,5 @@
 module Ethon
 
   # Ethon version.
-  VERSION = '0.14.0'
+  VERSION = '0.15.0'
 end

data/vendor/bundle/ruby/2.5.0/gems/{ethon-0.14.0 → ethon-0.15.0}/spec/ethon/easy/informations_spec.rb

@@ -94,5 +94,27 @@ describe Ethon::Easy::Informations do
     end
   end
 
+  describe "#size_upload" do
+    it "returns float" do
+      expect(easy.size_upload).to be_a(Float)
+    end
+  end
+
+  describe "#size_download" do
+    it "returns float" do
+      expect(easy.size_download).to be_a(Float)
+    end
+  end
 
+  describe "#speed_upload" do
+    it "returns float" do
+      expect(easy.speed_upload).to be_a(Float)
+    end
+  end
+
+  describe "#speed_download" do
+    it "returns float" do
+      expect(easy.speed_download).to be_a(Float)
+    end
+  end
 end

data/vendor/bundle/ruby/2.5.0/gems/{ethon-0.14.0 → ethon-0.15.0}/spec/ethon/easy/mirror_spec.rb

@@ -10,6 +10,7 @@ describe Ethon::Easy::Mirror do
       :return_code, :response_code, :response_body, :response_headers,
       :total_time, :starttransfer_time, :appconnect_time,
       :pretransfer_time, :connect_time, :namelookup_time, :redirect_time,
+      :size_upload, :size_download, :speed_upload, :speed_upload,
       :effective_url, :primary_ip, :redirect_count, :debug_info
     ].each do |name|
       it "contains #{name}" do

data/vendor/bundle/ruby/2.5.0/gems/ethon-0.15.0/spec/ethon/multi/options_spec.rb

@@ -0,0 +1,182 @@
+# frozen_string_literal: true
+require 'spec_helper'
+
+describe Ethon::Multi::Options do
+  let(:multi) { Ethon::Multi.new }
+
+  [
+    :maxconnects, :pipelining, :socketdata, :socketfunction,
+    :timerdata, :timerfunction, :max_total_connections
+  ].each do |name|
+    describe "#{name}=" do
+      it "responds_to" do
+        expect(multi).to respond_to("#{name}=")
+      end
+
+      it "sets option" do
+        expect(Ethon::Curl).to receive(:set_option).with(name, anything, anything, anything)
+        multi.method("#{name}=").call(1)
+      end
+    end
+  end
+
+  context "socket_action mode" do
+    let(:multi) { Ethon::Multi.new(execution_mode: :socket_action) }
+
+    describe "#socketfunction callbacks" do
+      it "allows multi_code return values" do
+        calls = []
+        multi.socketfunction = proc do |handle, sock, what, userp, socketp|
+          calls << what
+          :ok
+        end
+
+        easy = Ethon::Easy.new
+        easy.url = "http://localhost:3001/?delay=1"
+        multi.add(easy)
+        expect(calls).to eq([])
+        5.times do
+          multi.socket_action
+          break unless calls.empty?
+          sleep 0.1
+        end
+        expect(calls.last).to eq(:in).or(eq(:out))
+        multi.delete(easy)
+        expect(calls.last).to eq(:remove)
+      end
+
+      it "allows integer return values (compatibility)" do
+        called = false
+        multi.socketfunction = proc do |handle, sock, what, userp, socketp|
+          called = true
+          0
+        end
+
+        easy = Ethon::Easy.new
+        easy.url = "http://localhost:3001/?delay=1"
+        multi.add(easy)
+        5.times do
+          multi.socket_action
+          break if called
+          sleep 0.1
+        end
+        multi.delete(easy)
+
+        expect(called).to be_truthy
+      end
+
+      it "errors on invalid return codes" do
+        called = false
+        multi.socketfunction = proc do |handle, sock, what, userp, socketp|
+          called = true
+          "hi"
+        end
+
+        easy = Ethon::Easy.new
+        easy.url = "http://localhost:3001/?delay=1"
+        multi.add(easy)
+        expect {
+          5.times do
+            multi.socket_action
+            break if called
+            sleep 0.1
+          end
+        }.to raise_error(ArgumentError)
+        expect { multi.delete(easy) }.to raise_error(ArgumentError)
+      end
+    end
+
+    describe "#timerfunction callbacks" do
+      it "allows multi_code return values" do
+        calls = []
+        multi.timerfunction = proc do |handle, timeout_ms, userp|
+          calls << timeout_ms
+          :ok
+        end
+
+        easy = Ethon::Easy.new
+        easy.url = "http://localhost:3001/?delay=1"
+        multi.add(easy)
+        expect(calls.last).to be >= 0 # adds an immediate timeout
+
+        multi.delete(easy)
+        expect(calls.last).to eq(-1) # cancels the timer
+      end
+
+      it "allows integer return values (compatibility)" do
+        called = false
+        multi.timerfunction = proc do |handle, timeout_ms, userp|
+          called = true
+          0
+        end
+
+        easy = Ethon::Easy.new
+        easy.url = "http://localhost:3001/?delay=1"
+        multi.add(easy)
+        multi.socket_action
+        multi.delete(easy)
+
+        expect(called).to be_truthy
+      end
+
+      it "errors on invalid return codes" do
+        called = false
+        multi.timerfunction = proc do |handle, timeout_ms, userp|
+          called = true
+          "hi"
+        end
+
+        easy = Ethon::Easy.new
+        easy.url = "http://localhost:3001/?delay=1"
+        expect { multi.add(easy) }.to raise_error(ArgumentError)
+      end
+    end
+  end
+
+  describe "#value_for" do
+    context "when option in bool" do
+      context "when value true" do
+        let(:value) { true }
+
+        it "returns 1" do
+          expect(multi.method(:value_for).call(value, :bool)).to eq(1)
+        end
+      end
+
+      context "when value false" do
+        let(:value) { false }
+
+        it "returns 0" do
+          expect(multi.method(:value_for).call(value, :bool)).to eq(0)
+        end
+      end
+    end
+
+
+    context "when value in int" do
+      let(:value) { "2" }
+
+      it "returns value casted to int" do
+        expect(multi.method(:value_for).call(value, :int)).to eq(2)
+      end
+    end
+
+    context "when value in unspecific_options" do
+      context "when value a string" do
+        let(:value) { "www.example.\0com" }
+
+        it "returns zero byte escaped string" do
+          expect(multi.method(:value_for).call(value, nil)).to eq("www.example.\\0com")
+        end
+      end
+
+      context "when value not a string" do
+        let(:value) { 1 }
+
+        it "returns value" do
+          expect(multi.method(:value_for).call(value, nil)).to eq(1)
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.5.0/gems/ethon-0.15.0/spec/ethon/multi_spec.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+require 'spec_helper'
+
+describe Ethon::Multi do
+  describe ".new" do
+    it "inits curl" do
+      expect(Ethon::Curl).to receive(:init)
+      Ethon::Multi.new
+    end
+
+    context "with default options" do
+      it "allows running #perform with the default execution_mode" do
+        Ethon::Multi.new.perform
+      end
+
+      it "refuses to run #socket_action" do
+        expect { Ethon::Multi.new.socket_action }.to raise_error(ArgumentError)
+      end
+    end
+
+    context "when options not empty" do
+      context "when pipelining is set" do
+        let(:options) { { :pipelining => true } }
+
+        it "sets pipelining" do
+          expect_any_instance_of(Ethon::Multi).to receive(:pipelining=).with(true)
+          Ethon::Multi.new(options)
+        end
+      end
+
+      context "when execution_mode option is :socket_action" do
+        let(:options) { { :execution_mode => :socket_action } }
+        let(:multi) { Ethon::Multi.new(options) }
+
+        it "refuses to run #perform" do
+          expect { multi.perform }.to raise_error(ArgumentError)
+        end
+
+        it "allows running #socket_action" do
+          multi.socket_action
+        end
+      end
+    end
+  end
+
+  describe "#socket_action" do
+    let(:options) { { :execution_mode => :socket_action } }
+    let(:select_state) { { :readers => [], :writers => [], :timeout => 0 } }
+    let(:multi) {
+      multi = Ethon::Multi.new(options)
+      multi.timerfunction = proc do |handle, timeout_ms, userp|
+        timeout_ms = nil if timeout_ms == -1
+        select_state[:timeout] = timeout_ms
+        :ok
+      end
+      multi.socketfunction = proc do |handle, sock, what, userp, socketp|
+        case what
+        when :remove
+          select_state[:readers].delete(sock)
+          select_state[:writers].delete(sock)
+        when :in
+          select_state[:readers].push(sock) unless select_state[:readers].include? sock
+          select_state[:writers].delete(sock)
+        when :out
+          select_state[:readers].delete(sock)
+          select_state[:writers].push(sock) unless select_state[:writers].include? sock
+        when :inout
+          select_state[:readers].push(sock) unless select_state[:readers].include? sock
+          select_state[:writers].push(sock) unless select_state[:writers].include? sock
+        else
+          raise ArgumentError, "invalid value for 'what' in socketfunction callback"
+        end
+        :ok
+      end
+      multi
+    }
+
+    def fds_to_ios(fds)
+      fds.map do |fd|
+        IO.for_fd(fd).tap { |io| io.autoclose = false }
+      end
+    end
+
+    def perform_socket_action_until_complete
+      multi.socket_action # start things off
+
+      while multi.ongoing?
+        readers, writers, _ = IO.select(
+          fds_to_ios(select_state[:readers]),
+          fds_to_ios(select_state[:writers]),
+          [],
+          select_state[:timeout]
+        )
+
+        to_notify = Hash.new { |hash, key| hash[key] = [] }
+        unless readers.nil?
+          readers.each do |reader|
+            to_notify[reader] << :in
+          end
+        end
+        unless writers.nil?
+          writers.each do |writer|
+            to_notify[writer] << :out
+          end
+        end
+
+        to_notify.each do |io, readiness|
+          multi.socket_action(io, readiness)
+        end
+
+        # if we didn't have anything to notify, then we timed out
+        multi.socket_action if to_notify.empty?
+      end
+    ensure
+      multi.easy_handles.dup.each do |h|
+        multi.delete(h)
+      end
+    end
+
+    it "supports an end-to-end request" do
+      easy = Ethon::Easy.new
+      easy.url = "http://localhost:3001/"
+      multi.add(easy)
+
+      perform_socket_action_until_complete
+
+      expect(multi.ongoing?).to eq(false)
+    end
+
+    it "supports multiple concurrent requests" do
+      handles = []
+      10.times do
+        easy = Ethon::Easy.new
+        easy.url = "http://localhost:3001/?delay=1"
+        multi.add(easy)
+        handles << easy
+      end
+
+      start = Time.now
+      perform_socket_action_until_complete
+      duration = Time.now - start
+      
+      # these should have happened concurrently
+      expect(duration).to be < 2
+      expect(multi.ongoing?).to eq(false)
+
+      handles.each do |handle|
+        expect(handle.response_code).to eq(200)
+      end
+    end
+  end
+end