test-test-ignore-123123 0.0.1.pre.alpha.0

data/lib/sink/page_cursor_shared_ref.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Sink
+  class PageCursorSharedRef
+    class PageCursorSharedRefPagination < BaseModel
+      # @!attribute [rw] cursor
+      #   @return [String]
+      required :cursor, String
+
+      # @!attribute [rw] prop_with_another_ref
+      #   @return [Sink::Models::BasicSharedModelObject]
+      optional :prop_with_another_ref, -> { Sink::Models::BasicSharedModelObject }
+    end
+
+    # @return [Array]
+    attr_accessor :data
+
+    # @return [Sink::Models::PageCursorSharedRefPagination]
+    attr_accessor :pagination
+
+    # @!visibility private
+    attr_accessor :client, :req, :opts
+
+    # @!visibility private
+    def initialize(model, raw_data, _response, client, req, opts)
+      self.data = (raw_data[:data] || []).map { |e| model.convert(e) }
+      self.pagination = PageCursorSharedRefPagination.convert(raw_data[:pagination])
+      self.client = client
+      self.req = req
+      self.opts = opts
+    end
+
+    # @return [Boolean]
+    def next_page?
+      !pagination.cursor.nil?
+    end
+
+    # @return [PageCursorSharedRef]
+    def next_page
+      if !next_page?
+        raise "No more pages available; please check #next_page? before calling #next_page"
+      end
+      client.request(Util.deep_merge(req, {query: {cursor: cursor}}), opts)
+    end
+
+    # @return [nil]
+    def auto_paging_each(&blk)
+      if !blk
+        raise "A block must be given to #auto_paging_each"
+      end
+      page = self
+      loop do
+        page.data.each { |e| blk.call(e) }
+        break if !page.next_page?
+        page = page.next_page
+      end
+    end
+  end
+end

data/lib/sink/page_cursor_top_level_array.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Sink
+  class PageCursorTopLevelArray < ::Array
+    # @return [String]
+    attr_accessor :my_cursor
+
+    # @!visibility private
+    attr_accessor :client, :req, :opts
+
+    # @!visibility private
+    def initialize(model, raw_data, response, client, req, opts)
+      super(raw_data.map { |e| model.convert(e) })
+      self.my_cursor = response["X-My-Cursor"]
+      self.client = client
+      self.req = req
+      self.opts = opts
+    end
+
+    # @return [Boolean]
+    def next_page?
+      !my_cursor.nil?
+    end
+
+    # @return [PageCursorTopLevelArray]
+    def next_page
+      if !next_page?
+        raise "No more pages available; please check #next_page? before calling #next_page"
+      end
+      client.request(Util.deep_merge(req, {query: {cursor: my_cursor}}), opts)
+    end
+
+    # @return [nil]
+    def auto_paging_each(&blk)
+      if !blk
+        raise "A block must be given to #auto_paging_each"
+      end
+      page = self
+      loop do
+        page.each { |e| blk.call(e) }
+        break if !page.next_page?
+        page = page.next_page
+      end
+    end
+  end
+end

data/lib/sink/page_cursor_url.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Sink
+  class PageCursorURL
+    # @return [Array]
+    attr_accessor :data
+
+    # @return [String]
+    attr_accessor :next_page
+
+    # @!visibility private
+    attr_accessor :client, :req, :opts
+
+    # @!visibility private
+    def initialize(model, raw_data, _response, client, req, opts)
+      self.data = (raw_data[:data] || []).map { |e| model.convert(e) }
+      self.next_page = raw_data[:next_page]
+      self.client = client
+      self.req = req
+      self.opts = opts
+    end
+
+    # @return [Boolean]
+    def next_page?
+      raise NotImplementedError
+    end
+
+    # @return [PageCursorURL]
+    def next_page
+      raise NotImplementedError
+    end
+
+    # @return [nil]
+    def auto_paging_each(&blk)
+      if !blk
+        raise "A block must be given to #auto_paging_each"
+      end
+      page = self
+      loop do
+        page.data.each { |e| blk.call(e) }
+        break if !page.next_page?
+        page = page.next_page
+      end
+    end
+  end
+end

data/lib/sink/page_offset.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Sink
+  class PageOffset
+    # @return [Array]
+    attr_accessor :data
+
+    # @return [Integer]
+    attr_accessor :offset
+
+    # @!visibility private
+    attr_accessor :client, :req, :opts
+
+    # @!visibility private
+    def initialize(model, raw_data, _response, client, req, opts)
+      self.data = (raw_data[:data] || []).map { |e| model.convert(e) }
+      self.offset = raw_data[:offset]
+      self.client = client
+      self.req = req
+      self.opts = opts
+    end
+
+    # @return [Boolean]
+    def next_page?
+      data.empty?
+    end
+
+    # @return [PageOffset]
+    def next_page
+      if !next_page?
+        raise "No more pages available; please check #next_page? before calling #next_page"
+      end
+      client.request(Util.deep_merge(req, {query: {offset: offset + data.size}}), opts)
+    end
+
+    # @return [nil]
+    def auto_paging_each(&blk)
+      if !blk
+        raise "A block must be given to #auto_paging_each"
+      end
+      page = self
+      loop do
+        page.data.each { |e| blk.call(e) }
+        break if !page.next_page?
+        page = page.next_page
+      end
+    end
+  end
+end

data/lib/sink/page_offset_no_start_field.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Sink
+  class PageOffsetNoStartField
+    # @return [Array]
+    attr_accessor :data
+
+    # @!visibility private
+    attr_accessor :client, :req, :opts
+
+    # @!visibility private
+    def initialize(model, raw_data, _response, client, req, opts)
+      self.data = (raw_data[:data] || []).map { |e| model.convert(e) }
+      self.client = client
+      self.req = req
+      self.opts = opts
+    end
+
+    # @return [Boolean]
+    def next_page?
+      data.empty?
+    end
+
+    # @return [PageOffsetNoStartField]
+    def next_page
+      if !next_page?
+        raise "No more pages available; please check #next_page? before calling #next_page"
+      end
+      client.request(Util.deep_merge(req, {query: {offset: (opts[:params][:offset] || 0) + data.size}}), opts)
+    end
+
+    # @return [nil]
+    def auto_paging_each(&blk)
+      if !blk
+        raise "A block must be given to #auto_paging_each"
+      end
+      page = self
+      loop do
+        page.data.each { |e| blk.call(e) }
+        break if !page.next_page?
+        page = page.next_page
+      end
+    end
+  end
+end

data/lib/sink/page_offset_total_count.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Sink
+  class PageOffsetTotalCount
+    # @return [Array]
+    attr_accessor :data
+
+    # @return [Integer]
+    attr_accessor :total_count
+
+    # @return [Integer]
+    attr_accessor :offset
+
+    # @!visibility private
+    attr_accessor :client, :req, :opts
+
+    # @!visibility private
+    def initialize(model, raw_data, _response, client, req, opts)
+      self.data = (raw_data[:data] || []).map { |e| model.convert(e) }
+      self.total_count = raw_data[:total_count]
+      self.offset = raw_data[:offset]
+      self.client = client
+      self.req = req
+      self.opts = opts
+    end
+
+    # @return [Boolean]
+    def next_page?
+      offset + data.size < total_count
+    end
+
+    # @return [PageOffsetTotalCount]
+    def next_page
+      if !next_page?
+        raise "No more pages available; please check #next_page? before calling #next_page"
+      end
+      client.request(Util.deep_merge(req, {query: {offset: offset + data.size}}), opts)
+    end
+
+    # @return [nil]
+    def auto_paging_each(&blk)
+      if !blk
+        raise "A block must be given to #auto_paging_each"
+      end
+      page = self
+      loop do
+        page.data.each { |e| blk.call(e) }
+        break if !page.next_page?
+        page = page.next_page
+      end
+    end
+  end
+end

data/lib/sink/page_page_number.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Sink
+  class PagePageNumber
+    # @return [Array]
+    attr_accessor :data
+
+    # @return [Integer]
+    attr_accessor :page
+
+    # @return [Integer]
+    attr_accessor :last_page
+
+    # @!visibility private
+    attr_accessor :client, :req, :opts
+
+    # @!visibility private
+    def initialize(model, raw_data, _response, client, req, opts)
+      self.data = (raw_data[:data] || []).map { |e| model.convert(e) }
+      self.page = raw_data[:page]
+      self.last_page = raw_data[:last_page]
+      self.client = client
+      self.req = req
+      self.opts = opts
+    end
+
+    # @return [Boolean]
+    def next_page?
+      !data.empty?
+    end
+
+    # @return [PagePageNumber]
+    def next_page
+      if !next_page?
+        raise "No more pages available; please check #next_page? before calling #next_page"
+      end
+      client.request(Util.deep_merge(req, {query: {page: (req[:query][:page] || 1) + 1}}), opts)
+    end
+
+    # @return [nil]
+    def auto_paging_each(&blk)
+      if !blk
+        raise "A block must be given to #auto_paging_each"
+      end
+      page = self
+      loop do
+        page.data.each { |e| blk.call(e) }
+        break if !page.next_page?
+        page = page.next_page
+      end
+    end
+  end
+end

data/lib/sink/page_page_number_without_current_page_response.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Sink
+  class PagePageNumberWithoutCurrentPageResponse
+    # @return [Array]
+    attr_accessor :data
+
+    # @!visibility private
+    attr_accessor :client, :req, :opts
+
+    # @!visibility private
+    def initialize(model, raw_data, _response, client, req, opts)
+      self.data = (raw_data[:data] || []).map { |e| model.convert(e) }
+      self.client = client
+      self.req = req
+      self.opts = opts
+    end
+
+    # @return [Boolean]
+    def next_page?
+      !data.empty?
+    end
+
+    # @return [PagePageNumberWithoutCurrentPageResponse]
+    def next_page
+      if !next_page?
+        raise "No more pages available; please check #next_page? before calling #next_page"
+      end
+      client.request(Util.deep_merge(req, {query: {page: (req[:query][:page] || 1) + 1}}), opts)
+    end
+
+    # @return [nil]
+    def auto_paging_each(&blk)
+      if !blk
+        raise "A block must be given to #auto_paging_each"
+      end
+      page = self
+      loop do
+        page.data.each { |e| blk.call(e) }
+        break if !page.next_page?
+        page = page.next_page
+      end
+    end
+  end
+end

data/lib/sink/pooled_net_requester.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Sink
+  # @!visibility private
+  class PooledNetRequester
+    def initialize
+      @mutex = Mutex.new
+      @pools = {}
+    end
+
+    def get_pool(req)
+      hostname = req[:host]
+      scheme = req[:scheme]
+      port =
+        req[:port] ||
+        case scheme.to_sym
+        when :https
+          Net::HTTP.https_default_port
+        else
+          Net::HTTP.http_default_port
+        end
+      @mutex.synchronize do
+        @pools[hostname] ||= ConnectionPool.new do
+          conn = Net::HTTP.new(hostname, port)
+          conn.use_ssl = scheme.to_sym == :https
+          conn.start
+          conn
+        end
+        @pools[hostname]
+      end
+    end
+
+    def execute(req)
+      get_pool(req).with do |conn|
+        # Net can't understand posting to a URI representing only path + query,
+        # so we concatenate
+        uri_string = Sink::Util.uri_from_req(req, absolute: false)
+        case req[:method]
+        when :get
+          conn.get(uri_string, req[:headers])
+        when :patch
+          conn.patch(uri_string, req[:body], req[:headers])
+        when :put
+          conn.put(uri_string, req[:body], req[:headers])
+        when :post
+          conn.post(uri_string, req[:body], req[:headers])
+          # TODO: more verbs
+        when :delete
+          # `Net::HTTP`'s "convenience method" for delete doesn't accept a body
+          request = Net::HTTP::Delete.new(uri_string)
+          request.body = req[:body] if req[:body]
+          if req[:headers]
+            req[:headers].each { |k, v| request[k] = v }
+          end
+
+          conn.request(request)
+        else
+          raise NotImplementedError.new, req[:method]
+        end
+      end
+    end
+  end
+end

data/lib/sink/request_options.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Sink
+  # Specify HTTP behaviour to use for a specific request. These options supplement or override those
+  # provided at the client level.
+  #
+  # When making a request, you can pass an actual {RequestOptions} instance, or simply pass a Hash
+  # with symbol keys matching the attributes on this class.
+  class RequestOptions
+    # @!visibility private
+    def self.options
+      @options ||= []
+    end
+
+    # @!visibility private
+    def self.option(name)
+      define_method(name) { @_values[name] }
+      define_method("#{name}=") { |val| @_values[name] = val }
+      options.push(name)
+    end
+
+    # Returns a new instance of RequestOptions.
+    #
+    # @param values [Hash{Symbol => Object}] initial option values to set on the instance.
+    def initialize(values = {})
+      @_values = values
+    end
+
+    # @!attribute idempotency_key
+    # Idempotency key to send with request and all associated retries. Will only be sent for write
+    #   requests.
+    # @return [String]
+    option :idempotency_key
+
+    # @!attribute extra_headers
+    # Extra headers to send with the request. These are `.merged`’d into any `extra_headers` given at the
+    #  client level.
+    # @return [Hash{String => String}]
+    option :extra_headers
+
+    # @!attribute extra_query
+    # Extra query params to send with the request. These are `.merge`’d into any `query` given at
+    #   the client level.
+    # @return [Hash{Symbol => Object}]
+    option :extra_query
+
+    # @!attribute extra_body
+    # Extra data to send with the request. These are deep merged into any data generated as part
+    #   of the normal request.
+    # @return [Hash{Symbol => Object}]
+    option :extra_body
+
+    # @!attribute max_retries
+    # Maximum number of retries to attempt after a failed initial request.
+    # @return [Integer]
+    option :max_retries
+
+    # Lookup an option previously set on this instance.
+    #
+    # @return [Object]
+    def [](key)
+      @_values[key]
+    end
+
+    # Return a Hash containing the options set on this instance.
+    #
+    # @return [Hash{Symbol => Object}]
+    def to_h
+      @_values
+    end
+
+    alias_method :to_hash, :to_h
+
+    # @return [String]
+    def inspect
+      "#<Sink::RequestOptions:0x#{object_id.to_s(16)} #{@_values.inspect}>"
+    end
+
+    # @return [String]
+    def to_s
+      @_values.to_s
+    end
+  end
+end

data/lib/sink/resources/body_params/objects.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Sink
+  module Resources
+    class BodyParams
+      class Objects
+        def initialize(client:)
+          @client = client
+        end
+
+        # Endpoint with an object `requestBody` that has a property that uses
+        #   `additionalProperties: true` alongside defined properties
+        #
+        # @param params [Hash] Attributes to send in this request.
+        # @option params [MixedProp, nil] :mixed_prop
+        #
+        # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+        #
+        # @return [nil]
+        def mixed_known_and_unknown(params = {}, opts = {})
+          req = {}
+          req[:method] = :post
+          req[:path] = "/body_params/objects/mixed_known_and_unknown"
+          req[:body] = params
+          req[:model] = NilClass
+          @client.request(req, opts)
+        end
+      end
+    end
+  end
+end

data/lib/sink/resources/body_params/unions.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Sink
+  module Resources
+    class BodyParams
+      class Unions
+        def initialize(client:)
+          @client = client
+        end
+
+        # Defines a request parameter that is configured to generate a `NewType` type in
+        #   Python and is used in a union type alongside an enum.
+        #
+        # @param params [Hash] Attributes to send in this request.
+        # @option params [String, Symbol, Model::UnnamedTypeWithunionParent13, nil] :model
+        #
+        # @param opts [Hash, Sink::RequestOptions] Options to specify HTTP behaviour for this request.
+        #
+        # @return [nil]
+        def param_union_enum_new_type(params = {}, opts = {})
+          req = {}
+          req[:method] = :post
+          req[:path] = "/body_params/unions/param_union_enum_new_type"
+          req[:body] = params
+          req[:model] = NilClass
+          @client.request(req, opts)
+        end
+      end
+    end
+  end
+end