peal 0.1.0 → 0.3.0

data/lib/peal/internal/iterators/item_iterator.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module Peal
+  module Internal
+    class ItemIterator
+      include Enumerable
+
+      # The raw HTTP response from the most recent page request made by this pager or its `pages`.
+      # @return [Net::HTTPResponse, nil]
+      attr_reader :http_response
+
+      # Iterates over each item returned by the API, starting again from the first page on every call.
+      # Each loop is independent of other loops and of `next_element`.
+      #
+      # @param block [Proc] The block which each retrieved item is yielded to.
+      # @return [NilClass, Enumerator] An Enumerator when no block is given.
+      def each(&)
+        return enum_for(:each) unless block_given?
+
+        # Each loop reads through its own copy of the page stream, so repeated or nested loops never
+        # share a position with each other or with `next_element`.
+        pass = @item_pages.dup.tap(&:rewind)
+        while (page = pass.next_page)
+          (read_field(page, @item_field) || []).each(&)
+        end
+        nil
+      end
+
+      # Resets manual item-by-item iteration (`next_element` / `next?`) to the first page.
+      #
+      # @return [NilClass]
+      def rewind
+        @item_pages.rewind
+        @page = nil
+        @item_index = 0
+        nil
+      end
+
+      # Whether another item will be available from the API.
+      #
+      # @return [Boolean]
+      def next?
+        load_next_page if @page.nil?
+        return false if @page.nil?
+
+        return true if any_items_in_cached_page?
+
+        load_next_page
+        any_items_in_cached_page?
+      end
+
+      # Sends the request for the first page now instead of on the first iteration, so an API error for that page
+      # is raised here. The page is kept, and every loop (over items or `pages`) that starts from the first page
+      # reuses it instead of requesting it again. Does nothing if this pager already sent a request.
+      #
+      # @return [self]
+      def load_first_page
+        return self if @requested
+
+        @item_pages.load_first_page
+        @page_iterator.reuse_first_page(@item_pages)
+        self
+      end
+
+      # Retrieves the next item from the API.
+      def next_element
+        item = next_item_from_cached_page
+        return item if item
+
+        load_next_page
+        next_item_from_cached_page
+      end
+
+      private
+
+      # Wraps the page-fetching block so that `http_response` reflects the most recent request.
+      def track_http_responses(get_page)
+        proc do |*args|
+          result = get_page.call(*args)
+          @requested = true
+          @http_response = result[1] if result.is_a?(Array)
+          result
+        end
+      end
+
+      def cached_page_items
+        return [] unless @page
+
+        read_field(@page, @item_field) || []
+      end
+
+      def next_item_from_cached_page
+        items = cached_page_items
+        return if @item_index >= items.length
+
+        item = items[@item_index]
+        @item_index += 1
+        item
+      end
+
+      def any_items_in_cached_page?
+        @item_index < cached_page_items.length
+      end
+
+      def load_next_page
+        @page = @item_pages.next_page
+        @item_index = 0
+      end
+
+      # Reads a field from an API response, walking through enclosing objects when the field is nested.
+      #
+      # @param value [Object, nil] The API response.
+      # @param field [Symbol, Array<Symbol>] The field name, or the path of field names for a nested field.
+      # @return [Object, nil]
+      def read_field(value, field)
+        Array(field).reduce(value) { |object, name| object&.send(name) }
+      end
+    end
+  end
+end

data/lib/peal/internal/iterators/offset_item_iterator.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Peal
+  module Internal
+    class OffsetItemIterator < ItemIterator
+      # Instantiates an OffsetItemIterator, an Enumerable class which wraps calls to an offset-based paginated API and yields the individual items from it.
+      #
+      # @param initial_page [Integer] The initial page or offset to start from when iterating.
+      # @param item_field [Symbol, Array<Symbol>] The name (or nested path) of the field in API responses to extract the items to iterate over.
+      # @param has_next_field [Symbol, Array<Symbol>] The name (or nested path) of the field in API responses containing a boolean of whether another page exists.
+      # @param step [Boolean] If true, treats the page number as a true offset (i.e. increments the page number by the number of items returned from each call rather than just 1)
+      # @param block [Proc] A block which is responsible for receiving a page number to use and returning the given page from the API.
+      #
+      # @return [Peal::Internal::OffsetItemIterator]
+      def initialize(initial_page:, item_field:, has_next_field:, step:, &block)
+        super()
+        @item_field = item_field
+        @http_response = nil
+        get_page = track_http_responses(block)
+        @page_iterator = OffsetPageIterator.new(initial_page:, item_field:, has_next_field:, step:, &get_page)
+        # Items are read through their own page cursor so that reading `pages` never skips items.
+        @item_pages = OffsetPageIterator.new(initial_page:, item_field:, has_next_field:, step:, &get_page)
+        @page = nil
+        @item_index = 0
+      end
+
+      # Returns the OffsetPageIterator that is mediating access to the underlying API.
+      #
+      # @return [Peal::Internal::OffsetPageIterator]
+      def pages
+        @page_iterator
+      end
+    end
+  end
+end

data/lib/peal/internal/iterators/offset_page_iterator.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+module Peal
+  module Internal
+    class OffsetPageIterator
+      include Enumerable
+
+      # The raw HTTP response from the most recent page response.
+      # @return [Net::HTTPResponse, nil]
+      attr_reader :http_response
+
+      # Instantiates an OffsetPageIterator, an Enumerable class which wraps calls to an offset-based paginated API and yields pages of items from it.
+      #
+      # @param initial_page [Integer] The initial page to use when iterating, if any.
+      # @param item_field [Symbol, Array<Symbol>] The field (or nested path) to pull the list of items to iterate over.
+      # @param has_next_field [Symbol, Array<Symbol>] The field (or nested path) to pull the boolean of whether a next page exists from, if any.
+      # @param step [Boolean] If true, treats the page number as a true offset (i.e. increments the page number by the number of items returned from each call rather than just 1)
+      # @param block [Proc] A block which is responsible for receiving a page number to use and returning the given page from the API.
+      #   The block should return a two-element array: [parsed_page, raw_http_response].
+      # @return [Peal::Internal::OffsetPageIterator]
+      def initialize(initial_page:, item_field:, has_next_field:, step:, &block)
+        @initial_page = initial_page || (step ? 0 : 1)
+        @item_field = item_field
+        @has_next_field = has_next_field
+        @step = step
+        @get_next_page = block
+        @http_response = nil
+        @first_page_requested = false
+        @first_page = nil
+        rewind
+      end
+
+      # Sends the request for the first page now instead of on the first iteration, so an API error for that page
+      # is raised here. The page is kept, and every loop that starts from the first page reuses it instead of
+      # requesting it again (an empty first page ends those loops without a new request). Does nothing if the first
+      # page was already requested.
+      #
+      # @return [self]
+      def load_first_page
+        return self if @first_page_requested
+
+        @first_page = fetch_page(@initial_page)
+        rewind
+        self
+      end
+
+      # Uses the first page that `other` loaded with `load_first_page`, unless this iterator already sent a request.
+      #
+      # @param other [Peal::Internal::OffsetPageIterator]
+      # @return [NilClass]
+      def reuse_first_page(other)
+        return if @first_page_requested || other.first_page.nil?
+
+        @first_page = other.first_page
+        rewind
+      end
+
+      # Iterates over each page returned by the API, starting again from the first page on every call.
+      #
+      # @param block [Proc] The block which each retrieved page is yielded to.
+      # @return [NilClass, Enumerator] An Enumerator when no block is given.
+      def each(&block)
+        return enum_for(:each) unless block_given?
+
+        rewind
+        while (page = next_page)
+          block.call(page)
+        end
+      end
+
+      # Resets page-by-page iteration (`next_page` / `next?`) to the first page.
+      #
+      # @return [NilClass]
+      def rewind
+        @page_number = @initial_page
+        # A cache of whether the API has another page, if it gives us that information...
+        @has_next_page = nil
+        # ...or the actual next page, preloaded, if it doesn't. A first page kept by `load_first_page` is reused.
+        @next_page = @first_page
+        nil
+      end
+
+      # Whether another page will be available from the API.
+      #
+      # @return [Boolean]
+      def next?
+        return @has_next_page unless @has_next_page.nil?
+        return true if @next_page && page_has_items?(@next_page)
+        return @has_next_page = false if @next_page
+
+        fetched_page = fetch_page(@page_number)
+        fetched_page_items = read_field(fetched_page, @item_field)
+        if fetched_page_items.nil? || fetched_page_items.empty?
+          @has_next_page = false
+        else
+          @next_page = fetched_page
+          true
+        end
+      end
+
+      # Returns the next page from the API.
+      def next_page
+        return nil if @page_number.nil?
+
+        if @next_page
+          this_page = @next_page
+          @next_page = nil
+        else
+          this_page = fetch_page(@page_number)
+        end
+
+        @has_next_page = read_field(this_page, @has_next_field) if @has_next_field
+
+        items = read_field(this_page, @item_field)
+        if items.nil? || items.empty?
+          @page_number = nil
+          return nil
+        elsif @step
+          @page_number += items.length
+        else
+          @page_number += 1
+        end
+
+        this_page
+      end
+
+      protected
+
+      attr_reader :first_page
+
+      private
+
+      def page_has_items?(page)
+        items = read_field(page, @item_field)
+        !items.nil? && !items.empty?
+      end
+
+      def fetch_page(page_number)
+        result = @get_next_page.call(page_number)
+        @first_page_requested = true
+        if result.is_a?(Array)
+          fetched_page, raw_response = result
+          @http_response = raw_response
+          fetched_page
+        else
+          result
+        end
+      end
+
+      # Reads a field from an API response, walking through enclosing objects when the field is nested.
+      #
+      # @param value [Object, nil] The API response.
+      # @param field [Symbol, Array<Symbol>] The field name, or the path of field names for a nested field.
+      # @return [Object, nil]
+      def read_field(value, field)
+        Array(field).reduce(value) { |object, name| object&.send(name) }
+      end
+    end
+  end
+end

data/lib/peal/internal/json/request.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Peal
+  module Internal
+    module JSON
+      # @api private
+      class Request < Peal::Internal::Http::BaseRequest
+        attr_reader :body
+
+        # @param base_url [String] The base URL for the request
+        # @param path [String] The path for the request
+        # @param method [Symbol] The HTTP method for the request (:get, :post, etc.)
+        # @param headers [Hash] Additional headers for the request (optional)
+        # @param query [Hash] Query parameters for the request (optional)
+        # @param body [Object, nil] The JSON request body (optional)
+        # @param request_options [Peal::RequestOptions, Hash{Symbol=>Object}, nil]
+        # @param max_retries [Integer, nil] Overrides the client's retry count for this request
+        def initialize(base_url:, path:, method:, headers: {}, query: {}, body: nil, request_options: {}, max_retries: nil)
+          super(base_url:, path:, method:, headers:, query:, request_options:, max_retries:)
+
+          @body = body
+        end
+
+        # @return [Hash] The encoded HTTP request headers.
+        # @param protected_keys [Array<String>] Header keys set by the SDK client (e.g. auth, metadata)
+        #   that must not be overridden by additional_headers from request_options.
+        def encode_headers(protected_keys: [])
+          sdk_headers = {
+            "Content-Type" => "application/json",
+            "Accept" => "application/json"
+          }.merge(@headers)
+          merge_additional_headers(sdk_headers, protected_keys:)
+        end
+
+        # @return [String, nil] The encoded HTTP request body, including any additional_body_parameters
+        #   from request_options.
+        def encode_body
+          body = request_body
+          body.nil? ? nil : ::JSON.generate(Internal::Types::Utils.serialize_times(body))
+        end
+
+        private
+
+        # @return [Object, nil] The request body merged with additional_body_parameters.
+        def request_body
+          merge_additional_body_parameters(@body)
+        end
+      end
+    end
+  end
+end

data/lib/peal/internal/json/serializable.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Peal
+  module Internal
+    module JSON
+      module Serializable
+        # Loads data from JSON into its deserialized form
+        #
+        # @param str [String] Raw JSON to load into an object
+        # @return [Object]
+        def load(str)
+          raise NotImplementedError
+        end
+
+        # Dumps data from its deserialized form into JSON
+        #
+        # @param value [Object] The deserialized value
+        # @return [String]
+        def dump(value)
+          raise NotImplementedError
+        end
+      end
+    end
+  end
+end

data/lib/peal/internal/multipart/multipart_encoder.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+module Peal
+  module Internal
+    module Multipart
+      # Encodes parameters into a `multipart/form-data` payload as described by RFC
+      # 2388:
+      #
+      #     https://tools.ietf.org/html/rfc2388
+      #
+      # This is most useful for transferring file-like objects.
+      #
+      # Parameters should be added with `#encode`. When ready, use `#body` to get
+      # the encoded result and `#content_type` to get the value that should be
+      # placed in the `Content-Type` header of a subsequent request (which includes
+      # a boundary value).
+      #
+      # This abstraction is heavily inspired by Stripe's multipart/form-data implementation,
+      # which can be found here:
+      #
+      #     https://github.com/stripe/stripe-ruby/blob/ca00b676f04ac421cf5cb5ff0325f243651677b6/lib/stripe/multipart_encoder.rb#L18
+      #
+      # @api private
+      class Encoder
+        CONTENT_TYPE = "multipart/form-data"
+        CRLF = "\r\n"
+
+        attr_reader :boundary, :body
+
+        def initialize
+          # Chose the same number of random bytes that Go uses in its standard
+          # library implementation. Easily enough entropy to ensure that it won't
+          # be present in a file we're sending.
+          @boundary = SecureRandom.hex(30)
+
+          @body = String.new
+          @closed = false
+          @first_field = true
+        end
+
+        # Gets the content type string including the boundary.
+        #
+        # @return [String] The content type with boundary
+        def content_type
+          "#{CONTENT_TYPE}; boundary=#{@boundary}"
+        end
+
+        # Encode the given FormData object into a multipart/form-data payload.
+        #
+        # @param form_data [FormData] The form data to encode
+        # @return [String] The encoded body.
+        def encode(form_data)
+          return "" if form_data.parts.empty?
+
+          form_data.parts.each do |part|
+            write_part(part)
+          end
+          close
+
+          @body
+        end
+
+        # Writes a FormDataPart to the encoder.
+        #
+        # @param part [FormDataPart] The part to write
+        # @return [nil]
+        def write_part(part)
+          raise "Cannot write to closed encoder" if @closed
+
+          write_field(
+            name: part.name,
+            data: part.contents,
+            filename: part.filename,
+            headers: part.headers
+          )
+
+          nil
+        end
+
+        # Writes a field to the encoder.
+        #
+        # @param name [String] The field name
+        # @param data [String] The field data
+        # @param filename [String, nil] Optional filename
+        # @param headers [Hash<String, String>, nil] Optional additional headers
+        # @return [nil]
+        def write_field(name:, data:, filename: nil, headers: nil)
+          raise "Cannot write to closed encoder" if @closed
+
+          if @first_field
+            @first_field = false
+          else
+            @body << CRLF
+          end
+
+          @body << "--#{@boundary}#{CRLF}"
+          @body << %(Content-Disposition: form-data; name="#{escape(name.to_s)}")
+          @body << %(; filename="#{escape(filename)}") if filename
+          @body << CRLF
+
+          if headers
+            headers.each do |key, value|
+              @body << "#{key}: #{value}#{CRLF}"
+            end
+          elsif filename
+            # Default content type for files.
+            @body << "Content-Type: application/octet-stream#{CRLF}"
+          end
+
+          @body << CRLF
+          @body << data.to_s
+
+          nil
+        end
+
+        # Finalizes the encoder by writing the final boundary.
+        #
+        # @return [nil]
+        def close
+          raise "Encoder already closed" if @closed
+
+          @body << CRLF
+          @body << "--#{@boundary}--"
+          @closed = true
+
+          nil
+        end
+
+        private
+
+        # Escapes quotes for use in header values and replaces line breaks with spaces.
+        #
+        # @param str [String] The string to escape
+        # @return [String] The escaped string
+        def escape(str)
+          str.to_s.gsub('"', "%22").tr("\n", " ").tr("\r", " ")
+        end
+      end
+    end
+  end
+end

data/lib/peal/internal/multipart/multipart_form_data.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Peal
+  module Internal
+    module Multipart
+      # @api private
+      class FormData
+        # @return [Array<FormDataPart>] The parts in this multipart form data.
+        attr_reader :parts
+
+        # @return [Encoder] The encoder for this multipart form data.
+        private attr_reader :encoder
+
+        def initialize
+          @encoder = Encoder.new
+          @parts = []
+        end
+
+        # Adds a new part to the multipart form data.
+        #
+        # @param name [String] The name of the form field
+        # @param value [String, Integer, Float, Boolean, #read] The value of the field
+        # @param content_type [String, nil] Optional content type
+        # @return [self] Returns self for chaining
+        def add(name:, value:, content_type: nil)
+          headers = content_type ? { "Content-Type" => content_type } : nil
+          add_part(FormDataPart.new(name:, value:, headers:))
+        end
+
+        # Adds a file to the multipart form data.
+        #
+        # @param name [String] The name of the form field
+        # @param file [String, #read] A path to a file on disk, or a file/readable object
+        # @param filename [String, nil] Optional filename (defaults to basename of the path for paths and File objects,
+        #   and to the field name for readable objects without a path or name, such as StringIO)
+        # @param content_type [String, nil] Optional content type (e.g. "image/png")
+        # @return [self] Returns self for chaining
+        def add_file(name:, file:, filename: nil, content_type: nil)
+          headers = content_type ? { "Content-Type" => content_type } : nil
+          if file.is_a?(::String)
+            filename ||= ::File.basename(file)
+            file = ::File.binread(file)
+          else
+            filename ||= filename_for(file) || name
+          end
+          add_part(FormDataPart.new(name:, value: file, filename:, headers:))
+        end
+
+        # Adds a pre-created part to the multipart form data.
+        #
+        # @param part [FormDataPart] The part to add
+        # @return [self] Returns self for chaining
+        def add_part(part)
+          @parts << part
+          self
+        end
+
+        # Gets the content type string including the boundary.
+        #
+        # @return [String] The content type with boundary.
+        def content_type
+          @encoder.content_type
+        end
+
+        # Encode the multipart form data into a multipart/form-data payload.
+        #
+        # @return [String] The encoded body.
+        def encode
+          @encoder.encode(self)
+        end
+
+        private
+
+        def filename_for(file)
+          if file.is_a?(::File) || file.respond_to?(:path)
+            ::File.basename(file.path)
+          elsif file.respond_to?(:name)
+            file.name
+          end
+        end
+      end
+    end
+  end
+end

data/lib/peal/internal/multipart/multipart_form_data_part.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require "securerandom"
+
+module Peal
+  module Internal
+    module Multipart
+      # @api private
+      class FormDataPart
+        attr_reader :name, :contents, :filename, :headers
+
+        # @param name [String] The name of the form field
+        # @param value [String, Integer, Float, Boolean, File, #read] The value of the field
+        # @param filename [String, nil] Optional filename for file uploads
+        # @param headers [Hash<String, String>, nil] Optional additional headers
+        def initialize(name:, value:, filename: nil, headers: nil)
+          @name = name
+          @contents = convert_to_content(value)
+          @filename = filename
+          @headers = headers
+        end
+
+        # Converts the part to a hash suitable for serialization.
+        #
+        # @return [Hash] A hash representation of the part
+        def to_hash
+          result = {
+            name: @name,
+            contents: @contents
+          }
+          result[:filename] = @filename if @filename
+          result[:headers] = @headers if @headers
+          result
+        end
+
+        private
+
+        # Converts various types of values to a content representation
+        # @param value [String, Integer, Float, Boolean, #read] The value to convert
+        # @return [String] The string representation of the value
+        def convert_to_content(value)
+          if value.respond_to?(:read)
+            value.read
+          else
+            Internal::Types::Utils.serialize_times(value).to_s
+          end
+        end
+      end
+    end
+  end
+end