straddle 0.5.0 → 1.0.0

data/lib/straddle/internal/transport/pooled_net_requester.rb

@@ -31,12 +31,14 @@ module Straddle
                 Net::HTTP.https_default_port
               end
 
-            Net::HTTP.new(url.host, port).tap do
-              _1.use_ssl = %w[https wss].include?(url.scheme)
-              _1.max_retries = 0
+            Net::HTTP
+              .new(url.host, port)
+              .tap do
+                _1.use_ssl = %w[https wss].include?(url.scheme)
+                _1.max_retries = 0
 
-              (_1.cert_store = cert_store) if _1.use_ssl?
-            end
+                (_1.cert_store = cert_store) if _1.use_ssl?
+              end
           end
 
           # @api private
@@ -64,12 +66,13 @@ module Straddle
           # @return [Array(Net::HTTPGenericRequest, Proc)]
           def build_request(request, &blk)
             method, url, headers, body = request.fetch_values(:method, :url, :headers, :body)
-            req = Net::HTTPGenericRequest.new(
-              method.to_s.upcase,
-              !body.nil?,
-              method != :head,
-              URI(url.to_s) # ensure we construct a URI class of the right scheme
-            )
+            req =
+              Net::HTTPGenericRequest.new(
+                method.to_s.upcase,
+                !body.nil?,
+                method != :head,
+                URI(url.to_s) # ensure we construct a URI class of the right scheme
+              )
 
             headers.each { req[_1] = _2 }
 
@@ -134,60 +137,63 @@ module Straddle
           finished = false
 
           # rubocop:disable Metrics/BlockLength
-          enum = Enumerator.new do |y|
-            next if finished
-
-            with_pool(url, deadline: deadline) do |conn|
-              eof = false
-              closing = nil
-              ::Thread.handle_interrupt(Object => :never) do
-                ::Thread.handle_interrupt(Object => :immediate) do
-                  req, closing = self.class.build_request(request) do
-                    self.class.calibrate_socket_timeout(conn, deadline)
-                  end
+          enum =
+            Enumerator.new do |y|
+              next if finished
+
+              with_pool(url, deadline: deadline) do |conn|
+                eof = false
+                closing = nil
+                ::Thread.handle_interrupt(Object => :never) do
+                  ::Thread.handle_interrupt(Object => :immediate) do
+                    req, closing =
+                      self
+                      .class
+                      .build_request(request) { self.class.calibrate_socket_timeout(conn, deadline) }
 
-                  self.class.calibrate_socket_timeout(conn, deadline)
-                  unless conn.started?
-                    conn.keep_alive_timeout = self.class::KEEP_ALIVE_TIMEOUT
-                    conn.start
-                  end
-
-                  self.class.calibrate_socket_timeout(conn, deadline)
-                  ::Kernel.catch(:jump) do
-                    conn.request(req) do |rsp|
-                      y << [req, rsp]
-                      ::Kernel.throw(:jump) if finished
+                    self.class.calibrate_socket_timeout(conn, deadline)
+                    unless conn.started?
+                      conn.keep_alive_timeout = self.class::KEEP_ALIVE_TIMEOUT
+                      conn.start
+                    end
 
-                      rsp.read_body do |bytes|
-                        y << bytes.force_encoding(Encoding::BINARY)
+                    self.class.calibrate_socket_timeout(conn, deadline)
+                    ::Kernel.catch(:jump) do
+                      conn.request(req) do |rsp|
+                        y << [req, rsp]
                         ::Kernel.throw(:jump) if finished
 
-                        self.class.calibrate_socket_timeout(conn, deadline)
+                        rsp.read_body do |bytes|
+                          y << bytes.force_encoding(Encoding::BINARY)
+                          ::Kernel.throw(:jump) if finished
+
+                          self.class.calibrate_socket_timeout(conn, deadline)
+                        end
+                        eof = true
                       end
-                      eof = true
                     end
                   end
-                end
-              ensure
-                begin
-                  conn.finish if !eof && conn&.started?
                 ensure
-                  closing&.call
+                  begin
+                    conn.finish if !eof && conn&.started?
+                  ensure
+                    closing&.call
+                  end
                 end
               end
+            rescue Timeout::Error
+              raise Straddle::Errors::APITimeoutError.new(url: url, request: req)
+            rescue StandardError
+              raise Straddle::Errors::APIConnectionError.new(url: url, request: req)
             end
-          rescue Timeout::Error
-            raise Straddle::Errors::APITimeoutError.new(url: url, request: req)
-          rescue StandardError
-            raise Straddle::Errors::APIConnectionError.new(url: url, request: req)
-          end
           # rubocop:enable Metrics/BlockLength
 
           _, response = enum.next
-          body = Straddle::Internal::Util.fused_enum(enum, external: true) do
-            finished = true
-            loop { enum.next }
-          end
+          body =
+            Straddle::Internal::Util.fused_enum(enum, external: true) do
+              finished = true
+              loop { enum.next }
+            end
           [Integer(response.code), response, body]
         end
 
@@ -202,7 +208,15 @@ module Straddle
         end
 
         define_sorbet_constant!(:Request) do
-          T.type_alias { {method: Symbol, url: URI::Generic, headers: T::Hash[String, String], body: T.anything, deadline: Float} }
+          T.type_alias do
+            {
+              method: Symbol,
+              url: URI::Generic,
+              headers: T::Hash[String, String],
+              body: T.anything,
+              deadline: Float
+            }
+          end
         end
       end
     end

data/lib/straddle/internal/type/array_of.rb

@@ -46,9 +46,8 @@ module Straddle
         #
         # @return [Boolean]
         def ==(other)
-          # rubocop:disable Layout/LineLength
-          other.is_a?(Straddle::Internal::Type::ArrayOf) && other.nilable? == nilable? && other.item_type == item_type
-          # rubocop:enable Layout/LineLength
+          other.is_a?(Straddle::Internal::Type::ArrayOf) && other.nilable? == nilable? &&
+            other.item_type == item_type
         end
 
         # @api public
@@ -84,16 +83,15 @@ module Straddle
 
           target = item_type
           exactness[:yes] += 1
-          value
-            .map do |item|
-              case [nilable?, item]
-              in [true, nil]
-                exactness[:yes] += 1
-                nil
-              else
-                Straddle::Internal::Type::Converter.coerce(target, item, state: state)
-              end
+          value.map do |item|
+            case [nilable?, item]
+            in [true, nil]
+              exactness[:yes] += 1
+              nil
+            else
+              Straddle::Internal::Type::Converter.coerce(target, item, state: state)
             end
+          end
         end
 
         # @api private
@@ -108,9 +106,7 @@ module Straddle
         def dump(value, state:)
           target = item_type
           if value.is_a?(Array)
-            value.map do
-              Straddle::Internal::Type::Converter.dump(target, _1, state: state)
-            end
+            value.map { Straddle::Internal::Type::Converter.dump(target, _1, state: state) }
           else
             super
           end
@@ -160,7 +156,7 @@ module Straddle
         def inspect(depth: 0)
           items = Straddle::Internal::Type::Converter.inspect(item_type, depth: depth.succ)
 
-          "#{self.class}[#{[items, nilable? ? 'nil' : nil].compact.join(' | ')}]"
+          "#{self.class}[#{[items, nilable? ? "nil" : nil].compact.join(" | ")}]"
         end
       end
     end

data/lib/straddle/internal/type/base_model.rb

@@ -64,20 +64,20 @@ module Straddle
             setter = :"#{name_sym}="
             api_name = info.fetch(:api_name, name_sym)
             nilable = info.fetch(:nil?, false)
-            const = required && !nilable ? info.fetch(:const, Straddle::Internal::OMIT) : Straddle::Internal::OMIT
+            const =
+              required && !nilable ? info.fetch(:const, Straddle::Internal::OMIT) : Straddle::Internal::OMIT
 
             [name_sym, setter].each { undef_method(_1) } if known_fields.key?(name_sym)
 
-            known_fields[name_sym] =
-              {
-                mode: @mode,
-                api_name: api_name,
-                required: required,
-                nilable: nilable,
-                const: const,
-                type_fn: type_fn,
-                meta: meta
-              }
+            known_fields[name_sym] = {
+              mode: @mode,
+              api_name: api_name,
+              required: required,
+              nilable: nilable,
+              const: const,
+              type_fn: type_fn,
+              meta: meta
+            }
 
             define_method(setter) do |value|
               target = type_fn.call
@@ -117,9 +117,7 @@ module Straddle
                   if (nilable || !required) && value.nil?
                     nil
                   else
-                    Straddle::Internal::Type::Converter.coerce(
-                      target, value, state: state
-                    )
+                    Straddle::Internal::Type::Converter.coerce(target, value, state: state)
                   end
                 rescue StandardError => e
                   raise Straddle::Errors::ConversionError.new(
@@ -437,19 +435,10 @@ module Straddle
         #
         # @return [Hash{Symbol=>Object}]
         #
-        # @example
-        #   # `customer_details_v1` is a `Straddle::CustomerDetailsV1`
-        #   customer_details_v1 => {
-        #     id: id,
-        #     customer_type: customer_type,
-        #     email: email
-        #   }
         def deconstruct_keys(keys)
           (keys || self.class.known_fields.keys)
             .filter_map do |k|
-              unless self.class.known_fields.key?(k)
-                next
-              end
+              next unless self.class.known_fields.key?(k)
 
               [k, public_send(k)]
             end
@@ -476,14 +465,16 @@ module Straddle
         def initialize(data = {})
           @data = {}
           @coerced = {}
-          Straddle::Internal::Util.coerce_hash!(data).each do
-            if self.class.known_fields.key?(_1)
-              public_send(:"#{_1}=", _2)
-            else
-              @data.store(_1, _2)
-              @coerced.store(_1, false)
+          Straddle::Internal::Util
+            .coerce_hash!(data)
+            .each do
+              if self.class.known_fields.key?(_1)
+                public_send(:"#{_1}=", _2)
+              else
+                @data.store(_1, _2)
+                @coerced.store(_1, false)
+              end
             end
-          end
         end
 
         class << self
@@ -496,14 +487,15 @@ module Straddle
             return super() if depth.positive?
 
             depth = depth.succ
-            deferred = fields.transform_values do |field|
-              type, required, nilable = field.fetch_values(:type, :required, :nilable)
-              inspected = [
-                Straddle::Internal::Type::Converter.inspect(type, depth: depth),
-                !required || nilable ? "nil" : nil
-              ].compact.join(" | ")
-              -> { inspected }.tap { _1.define_singleton_method(:inspect) { call } }
-            end
+            deferred =
+              fields.transform_values do |field|
+                type, required, nilable = field.fetch_values(:type, :required, :nilable)
+                inspected = [
+                  Straddle::Internal::Type::Converter.inspect(type, depth: depth),
+                  !required || nilable ? "nil" : nil
+                ].compact.join(" | ")
+                -> { inspected }.tap { _1.define_singleton_method(:inspect) { call } }
+              end
 
             "#{name}[#{deferred.inspect}]"
           end

data/lib/straddle/internal/type/converter.rb

@@ -134,7 +134,11 @@ module Straddle
             {
               translate_names: translate_names,
               strictness: true,
-              exactness: {yes: 0, no: 0, maybe: 0},
+              exactness: {
+                yes: 0,
+                no: 0,
+                maybe: 0
+              },
               error: nil,
               branched: 0
             }
@@ -312,15 +316,17 @@ module Straddle
             {
               translate_names: T::Boolean,
               strictness: T::Boolean,
-              exactness: {yes: Integer, no: Integer, maybe: Integer},
+              exactness: {
+                yes: Integer,
+                no: Integer,
+                maybe: Integer
+              },
               error: T::Class[StandardError],
               branched: Integer
             }
           end
         end
-        define_sorbet_constant!(:DumpState) do
-          T.type_alias { {can_retry: T::Boolean} }
-        end
+        define_sorbet_constant!(:DumpState) { T.type_alias { {can_retry: T::Boolean} } }
       end
     end
   end

data/lib/straddle/internal/type/enum.rb

@@ -15,6 +15,7 @@ module Straddle
       #
       # We can therefore convert string values to Symbols, but can't convert other
       # values safely.
+      #
       module Enum
         include Straddle::Internal::Type::Converter
         include Straddle::Internal::Util::SorbetRuntimeSupport
@@ -116,14 +117,12 @@ module Straddle
         #
         # @return [String]
         def inspect(depth: 0)
-          if depth.positive?
-            return is_a?(Module) ? super() : self.class.name
-          end
+          return is_a?(Module) ? super() : self.class.name if depth.positive?
 
           members = values.map { Straddle::Internal::Type::Converter.inspect(_1, depth: depth.succ) }
           prefix = is_a?(Module) ? name : self.class.name
 
-          "#{prefix}[#{members.join(' | ')}]"
+          "#{prefix}[#{members.join(" | ")}]"
         end
       end
     end

data/lib/straddle/internal/type/hash_of.rb

@@ -61,9 +61,8 @@ module Straddle
         #
         # @return [Boolean]
         def ==(other)
-          # rubocop:disable Layout/LineLength
-          other.is_a?(Straddle::Internal::Type::HashOf) && other.nilable? == nilable? && other.item_type == item_type
-          # rubocop:enable Layout/LineLength
+          other.is_a?(Straddle::Internal::Type::HashOf) && other.nilable? == nilable? &&
+            other.item_type == item_type
         end
 
         # @api public
@@ -99,21 +98,20 @@ module Straddle
 
           target = item_type
           exactness[:yes] += 1
-          value
-            .to_h do |key, val|
-              k = key.is_a?(String) ? key.to_sym : key
-              v =
-                case [nilable?, val]
-                in [true, nil]
-                  exactness[:yes] += 1
-                  nil
-                else
-                  Straddle::Internal::Type::Converter.coerce(target, val, state: state)
-                end
-
-              exactness[:no] += 1 unless k.is_a?(Symbol)
-              [k, v]
-            end
+          value.to_h do |key, val|
+            k = key.is_a?(String) ? key.to_sym : key
+            v =
+              case [nilable?, val]
+              in [true, nil]
+                exactness[:yes] += 1
+                nil
+              else
+                Straddle::Internal::Type::Converter.coerce(target, val, state: state)
+              end
+
+            exactness[:no] += 1 unless k.is_a?(Symbol)
+            [k, v]
+          end
         end
 
         # @api private
@@ -128,9 +126,7 @@ module Straddle
         def dump(value, state:)
           target = item_type
           if value.is_a?(Hash)
-            value.transform_values do
-              Straddle::Internal::Type::Converter.dump(target, _1, state: state)
-            end
+            value.transform_values { Straddle::Internal::Type::Converter.dump(target, _1, state: state) }
           else
             super
           end
@@ -180,7 +176,7 @@ module Straddle
         def inspect(depth: 0)
           items = Straddle::Internal::Type::Converter.inspect(item_type, depth: depth.succ)
 
-          "#{self.class}[#{[items, nilable? ? 'nil' : nil].compact.join(' | ')}]"
+          "#{self.class}[#{[items, nilable? ? "nil" : nil].compact.join(" | ")}]"
         end
       end
     end

data/lib/straddle/internal/type/union.rb

@@ -4,6 +4,7 @@ module Straddle
   module Internal
     module Type
       # @api private
+      #
       module Union
         include Straddle::Internal::Type::Converter
         include Straddle::Internal::Util::SorbetRuntimeSupport
@@ -73,9 +74,7 @@ module Straddle
           in [_, Straddle::Internal::Type::BaseModel]
             value.class
           in [Symbol, Hash]
-            key = value.fetch(@discriminator) do
-              value.fetch(@discriminator.to_s, Straddle::Internal::OMIT)
-            end
+            key = value.fetch(@discriminator) { value.fetch(@discriminator.to_s, Straddle::Internal::OMIT) }
 
             return nil if key == Straddle::Internal::OMIT
 
@@ -96,9 +95,7 @@ module Straddle
         #
         # @return [Boolean]
         def ===(other)
-          known_variants.any? do |_, variant_fn|
-            variant_fn.call === other
-          end
+          known_variants.any? { |_, variant_fn| variant_fn.call === other }
         end
 
         # @api public
@@ -170,8 +167,7 @@ module Straddle
           in [[_, exact, coerced], *]
             exact.each { exactness[_1] += _2 }
             coerced
-          end
-            .tap { state[:exactness] = exactness }
+          end.tap { state[:exactness] = exactness }
         ensure
           state[:strictness] = strictness
         end
@@ -222,14 +218,12 @@ module Straddle
         #
         # @return [String]
         def inspect(depth: 0)
-          if depth.positive?
-            return is_a?(Module) ? super() : self.class.name
-          end
+          return is_a?(Module) ? super() : self.class.name if depth.positive?
 
           members = variants.map { Straddle::Internal::Type::Converter.inspect(_1, depth: depth.succ) }
           prefix = is_a?(Module) ? name : self.class.name
 
-          "#{prefix}[#{members.join(' | ')}]"
+          "#{prefix}[#{members.join(" | ")}]"
         end
       end
     end