test-test-sink-test-test 0.0.2.pre.alpha.0

data/lib/sink/page_cursor_nested_object_ref.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Sink
+  class PageCursorNestedObjectRef
+    class ObjectProp < BaseModel
+      # @!attribute [rw] foo
+      #   @return [String]
+      optional :foo, String
+
+      # @!parse
+      #   # Create a new instance of ObjectProp from a Hash of raw data.
+      #   #
+      #   # @param data [Hash{Symbol => Object}] .
+      #   #   @option data [String, nil] :foo
+      #   def initialize(data = {}) = super
+    end
+
+    # @return [Array]
+    attr_accessor :data
+
+    # @return [String]
+    attr_accessor :nested_object_cursor
+
+    # @return [ObjectProp]
+    attr_accessor :object_prop
+
+    # @!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.nested_object_cursor = raw_data[:nested_object_cursor]
+      self.object_prop = ObjectProp.convert(raw_data[:object_prop])
+      self.client = client
+      self.req = req
+      self.opts = opts
+    end
+
+    # @return [Boolean]
+    def next_page?
+      !nested_object_cursor.nil?
+    end
+
+    # @return [Sink::PageCursorNestedObjectRef]
+    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: nested_object_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
+
+    # @return String
+    def inspect
+      "#<#{selfl.class}:0x#{object_id.to_s(16)} data=#{data.inspect} nested_object_cursor=#{nested_object_cursor.inspect} object_prop=#{object_prop.inspect}>"
+    end
+  end
+end

data/lib/sink/page_cursor_shared_ref.rb

@@ -0,0 +1,72 @@
+# 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 }
+
+      # @!parse
+      #   # Create a new instance of PageCursorSharedRefPagination from a Hash of raw data.
+      #   #
+      #   # @param data [Hash{Symbol => Object}] .
+      #   #   @option data [String] :cursor
+      #   #   @option data [Object, nil] :prop_with_another_ref
+      #   def initialize(data = {}) = super
+    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 [Sink::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
+
+    # @return String
+    def inspect
+      "#<#{selfl.class}:0x#{object_id.to_s(16)} data=#{data.inspect} pagination=#{pagination.inspect}>"
+    end
+  end
+end

data/lib/sink/page_cursor_top_level_array.rb

@@ -0,0 +1,51 @@
+# 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 [Sink::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
+
+    # @return String
+    def inspect
+      "#<#{selfl.class}:0x#{object_id.to_s(16)} my_cursor=#{my_cursor.inspect}>"
+    end
+  end
+end

data/lib/sink/page_cursor_url.rb

@@ -0,0 +1,51 @@
+# 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 [Sink::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
+
+    # @return String
+    def inspect
+      "#<#{selfl.class}:0x#{object_id.to_s(16)} data=#{data.inspect} next_page=#{next_page.inspect}>"
+    end
+  end
+end

data/lib/sink/page_cursor_with_reverse.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Sink
+  class PageCursorWithReverse
+    # @return [Array]
+    attr_accessor :data
+
+    # @return [String]
+    attr_accessor :first_id
+
+    # @return [String]
+    attr_accessor :last_id
+
+    # @!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.first_id = raw_data[:first_id]
+      self.last_id = raw_data[:last_id]
+      self.client = client
+      self.req = req
+      self.opts = opts
+    end
+
+    # @return [Boolean]
+    def next_page?
+      !last_id.nil?
+    end
+
+    # @return [Sink::PageCursorWithReverse]
+    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: {after_id: last_id}}), 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
+
+    # @return String
+    def inspect
+      "#<#{selfl.class}:0x#{object_id.to_s(16)} data=#{data.inspect} first_id=#{first_id.inspect} last_id=#{last_id.inspect}>"
+    end
+  end
+end

data/lib/sink/page_offset.rb

@@ -0,0 +1,54 @@
+# 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 [Sink::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
+
+    # @return String
+    def inspect
+      "#<#{selfl.class}:0x#{object_id.to_s(16)} data=#{data.inspect} offset=#{offset.inspect}>"
+    end
+  end
+end

data/lib/sink/page_offset_no_start_field.rb

@@ -0,0 +1,50 @@
+# 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 [Sink::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
+
+    # @return String
+    def inspect
+      "#<#{selfl.class}:0x#{object_id.to_s(16)} data=#{data.inspect}>"
+    end
+  end
+end

data/lib/sink/page_offset_total_count.rb

@@ -0,0 +1,58 @@
+# 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 [Sink::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
+
+    # @return String
+    def inspect
+      "#<#{selfl.class}:0x#{object_id.to_s(16)} data=#{data.inspect} total_count=#{total_count.inspect} offset=#{offset.inspect}>"
+    end
+  end
+end

data/lib/sink/page_page_number.rb

@@ -0,0 +1,58 @@
+# 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 [Sink::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
+
+    # @return String
+    def inspect
+      "#<#{selfl.class}:0x#{object_id.to_s(16)} data=#{data.inspect} page=#{page.inspect} last_page=#{last_page.inspect}>"
+    end
+  end
+end

data/lib/sink/page_page_number_without_current_page_response.rb

@@ -0,0 +1,50 @@
+# 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 [Sink::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
+
+    # @return String
+    def inspect
+      "#<#{selfl.class}:0x#{object_id.to_s(16)} data=#{data.inspect}>"
+    end
+  end
+end

data/lib/sink/pooled_net_requester.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Sink
+  # @!visibility private
+  class PooledNetRequester
+    def initialize
+      @mutex = Mutex.new
+      @pools = {}
+    end
+
+    def get_pool(req, timeout:)
+      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.max_retries = 0
+          conn.open_timeout = timeout
+          conn.start
+          conn
+        end
+        @pools[hostname]
+      end
+    end
+
+    def execute(req, timeout:)
+      method, headers, body = req.values_at(:method, :headers, :body)
+      get_pool(req, timeout: timeout).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)
+
+        request = Net::HTTPGenericRequest.new(
+          method.to_s.upcase,
+          !body.nil?,
+          method != :head,
+          uri_string
+        )
+
+        content_type = headers["content-type"]
+        if content_type == "multipart/form-data" && body
+          form_data =
+            body.filter_map do |k, v|
+              next if v.nil?
+              [k.to_s, v].flatten
+            end
+          request.set_form(form_data, content_type)
+          headers = headers.merge("content-type" => nil)
+        else
+          request.body = body
+        end
+
+        headers.each do |k, v|
+          request[k] = v
+        end
+
+        conn.read_timeout = timeout
+        conn.write_timeout = timeout
+        conn.request(request)
+      end
+    end
+  end
+end