httpx 0.15.3 → 0.17.0

data/lib/httpx/plugins/aws_sigv4.rb

@@ -141,22 +141,23 @@ module HTTPX
       end
 
       class << self
-        def extra_options(options)
-          Class.new(options.class) do
-            def_option(:sigv4_signer, <<-OUT)
-              value.is_a?(#{Signer}) ? value : #{Signer}.new(value)
-            OUT
-          end.new(options)
-        end
-
-        def load_dependencies(klass)
+        def load_dependencies(*)
           require "digest/sha2"
           require "openssl"
+        end
+
+        def configure(klass)
           klass.plugin(:expect)
           klass.plugin(:compression)
         end
       end
 
+      module OptionsMethods
+        def option_sigv4_signer(value)
+          value.is_a?(Signer) ? value : Signer.new(value)
+        end
+      end
+
       module InstanceMethods
         def aws_sigv4_authentication(**options)
           with(sigv4_signer: Signer.new(**options))

data/lib/httpx/plugins/compression.rb

@@ -23,21 +23,22 @@ module HTTPX
           encodings = Module.new do
             extend Registry
           end
+          options.merge(encodings: encodings)
+        end
+      end
 
-          Class.new(options.class) do
-            def_option(:compression_threshold_size, <<-OUT)
-              bytes = Integer(value)
-              raise Error, ":expect_threshold_size must be positive" unless bytes.positive?
+      module OptionsMethods
+        def option_compression_threshold_size(value)
+          bytes = Integer(value)
+          raise TypeError, ":expect_threshold_size must be positive" unless bytes.positive?
 
-              bytes
-            OUT
+          bytes
+        end
 
-            def_option(:encodings, <<-OUT)
-              raise Error, ":encodings must be a registry" unless value.respond_to?(:registry)
+        def option_encodings(value)
+          raise TypeError, ":encodings must be a registry" unless value.respond_to?(:registry)
 
-              value
-            OUT
-          end.new(options).merge(encodings: encodings)
+          value
         end
       end
 

data/lib/httpx/plugins/cookies/cookie.rb

@@ -43,7 +43,7 @@ module HTTPX
         # Precedence: 1. longer path  2. older creation
         (@name <=> other.name).nonzero? ||
           (other.path.length <=> @path.length).nonzero? ||
-          (@created_at <=> other.created_at).nonzero?
+          (@created_at <=> other.created_at).nonzero? || 0
       end
 
       class << self
@@ -107,6 +107,8 @@ module HTTPX
 
         @path ||= "/"
         raise ArgumentError, "name must be specified" if @name.nil?
+
+        @name = @name.to_s
       end
 
       def expires
@@ -122,7 +124,7 @@ module HTTPX
       # Returns a string for use in the Cookie header, i.e. `name=value`
       # or `name="value"`.
       def cookie_value
-        "#{@name}=#{Scanner.quote(@value)}"
+        "#{@name}=#{Scanner.quote(@value.to_s)}"
       end
       alias_method :to_s, :cookie_value
 

data/lib/httpx/plugins/cookies/jar.rb

@@ -57,7 +57,7 @@ module HTTPX
       def each(uri = nil, &blk)
         return enum_for(__method__, uri) unless block_given?
 
-        return @store.each(&blk) unless uri
+        return @cookies.each(&blk) unless uri
 
         uri = URI(uri)
 
@@ -73,6 +73,25 @@ module HTTPX
           end
         end
       end
+
+      def merge(other)
+        cookies_dup = dup
+
+        other.each do |elem|
+          cookie = case elem
+                   when Cookie
+                     elem
+                   when Array
+                     Cookie.new(*elem)
+                   else
+                     Cookie.new(elem)
+          end
+
+          cookies_dup.add(cookie)
+        end
+
+        cookies_dup
+      end
     end
   end
 end

data/lib/httpx/plugins/cookies.rb

@@ -18,12 +18,10 @@ module HTTPX
         require "httpx/plugins/cookies/set_cookie_parser"
       end
 
-      def self.extra_options(options)
-        Class.new(options.class) do
-          def_option(:cookies, <<-OUT)
-            value.is_a?(#{Jar}) ? value : #{Jar}.new(value)
-          OUT
-        end.new(options)
+      module OptionsMethods
+        def option_cookies(value)
+          value.is_a?(Jar) ? value : Jar.new(value)
+        end
       end
 
       module InstanceMethods
@@ -63,7 +61,7 @@ module HTTPX
 
         def build_request(*, _)
           request = super
-          request.headers.set_cookie(@options.cookies[request.uri])
+          request.headers.set_cookie(request.options.cookies[request.uri])
           request
         end
       end
@@ -77,6 +75,21 @@ module HTTPX
           add("cookie", header_value)
         end
       end
+
+      module OptionsMethods
+        def initialize(*)
+          super
+
+          return unless @headers.key?("cookie")
+
+          @headers.delete("cookie").each do |ck|
+            ck.split(/ *; */).each do |cookie|
+              name, value = cookie.split("=", 2)
+              @cookies.add(Cookie.new(name, value))
+            end
+          end
+        end
+      end
     end
     register_plugin :cookies, Cookies
   end

data/lib/httpx/plugins/digest_authentication.rb

@@ -14,19 +14,23 @@ module HTTPX
 
       DigestError = Class.new(Error)
 
-      def self.extra_options(options)
-        Class.new(options.class) do
-          def_option(:digest, <<-OUT)
-            raise Error, ":digest must be a Digest" unless value.is_a?(#{Digest})
-
-            value
-          OUT
-        end.new(options).merge(max_concurrent_requests: 1)
+      class << self
+        def extra_options(options)
+          options.merge(max_concurrent_requests: 1)
+        end
+
+        def load_dependencies(*)
+          require "securerandom"
+          require "digest"
+        end
       end
 
-      def self.load_dependencies(*)
-        require "securerandom"
-        require "digest"
+      module OptionsMethods
+        def option_digest(value)
+          raise TypeError, ":digest must be a Digest" unless value.is_a?(Digest)
+
+          value
+        end
       end
 
       module InstanceMethods
@@ -36,12 +40,12 @@ module HTTPX
 
         alias_method :digest_auth, :digest_authentication
 
-        def send_requests(*requests, options)
+        def send_requests(*requests)
           requests.flat_map do |request|
             digest = request.options.digest
 
             if digest
-              probe_response = wrap { super(request, options).first }
+              probe_response = wrap { super(request).first }
 
               if digest && !probe_response.is_a?(ErrorResponse) &&
                  probe_response.status == 401 && probe_response.headers.key?("www-authenticate") &&
@@ -52,12 +56,12 @@ module HTTPX
                 token = digest.generate_header(request, probe_response)
                 request.headers["authorization"] = "Digest #{token}"
 
-                super(request, options)
+                super(request)
               else
                 probe_response
               end
             else
-              super(request, options)
+              super(request)
             end
           end
         end

data/lib/httpx/plugins/expect.rb

@@ -10,26 +10,30 @@ module HTTPX
     module Expect
       EXPECT_TIMEOUT = 2
 
-      def self.no_expect_store
-        @no_expect_store ||= []
+      class << self
+        def no_expect_store
+          @no_expect_store ||= []
+        end
+
+        def extra_options(options)
+          options.merge(expect_timeout: EXPECT_TIMEOUT)
+        end
       end
 
-      def self.extra_options(options)
-        Class.new(options.class) do
-          def_option(:expect_timeout, <<-OUT)
-            seconds = Integer(value)
-            raise Error, ":expect_timeout must be positive" unless seconds.positive?
+      module OptionsMethods
+        def option_expect_timeout(value)
+          seconds = Integer(value)
+          raise TypeError, ":expect_timeout must be positive" unless seconds.positive?
 
-            seconds
-          OUT
+          seconds
+        end
 
-          def_option(:expect_threshold_size, <<-OUT)
-            bytes = Integer(value)
-            raise Error, ":expect_threshold_size must be positive" unless bytes.positive?
+        def option_expect_threshold_size(value)
+          bytes = Integer(value)
+          raise TypeError, ":expect_threshold_size must be positive" unless bytes.positive?
 
-            bytes
-          OUT
-        end.new(options).merge(expect_timeout: EXPECT_TIMEOUT)
+          bytes
+        end
       end
 
       module RequestMethods

data/lib/httpx/plugins/follow_redirects.rb

@@ -17,17 +17,17 @@ module HTTPX
       MAX_REDIRECTS = 3
       REDIRECT_STATUS = (300..399).freeze
 
-      def self.extra_options(options)
-        Class.new(options.class) do
-          def_option(:max_redirects, <<-OUT)
-            num = Integer(value)
-            raise Error, ":max_redirects must be positive" if num.negative?
+      module OptionsMethods
+        def option_max_redirects(value)
+          num = Integer(value)
+          raise TypeError, ":max_redirects must be positive" if num.negative?
 
-            num
-          OUT
+          num
+        end
 
-          def_option(:follow_insecure_redirects)
-        end.new(options)
+        def option_follow_insecure_redirects(value)
+          value
+        end
       end
 
       module InstanceMethods

data/lib/httpx/plugins/grpc/call.rb

@@ -10,6 +10,7 @@ module HTTPX
         def initialize(response)
           @response = response
           @decoder = ->(z) { z }
+          @consumed = false
         end
 
         def inspect
@@ -25,7 +26,7 @@ module HTTPX
         end
 
         def trailing_metadata
-          return unless @response.body.closed?
+          return unless @consumed
 
           @response.trailing_metadata
         end
@@ -40,8 +41,10 @@ module HTTPX
               Message.stream(@response).each do |message|
                 y << @decoder.call(message)
               end
+              @consumed = true
             end
           else
+            @consumed = true
             @decoder.call(Message.unary(@response))
           end
         end

data/lib/httpx/plugins/grpc.rb

@@ -49,7 +49,6 @@ module HTTPX
       class << self
         def load_dependencies(*)
           require "stringio"
-          require "google/protobuf"
           require "httpx/plugins/grpc/message"
           require "httpx/plugins/grpc/call"
         end
@@ -61,36 +60,7 @@ module HTTPX
         end
 
         def extra_options(options)
-          Class.new(options.class) do
-            def_option(:grpc_service, <<-OUT)
-              String(value)
-            OUT
-
-            def_option(:grpc_compression, <<-OUT)
-              case value
-              when true, false
-                value
-              else
-                value.to_s
-              end
-            OUT
-
-            def_option(:grpc_rpcs, <<-OUT)
-              Hash[value]
-            OUT
-
-            def_option(:grpc_deadline, <<-OUT)
-              raise Error, ":grpc_deadline must be positive" unless value.positive?
-
-              value
-            OUT
-
-            def_option(:call_credentials, <<-OUT)
-              raise Error, ":call_credentials must respond to #call" unless value.respond_to?(:call)
-
-              value
-            OUT
-          end.new(options).merge(
+          options.merge(
             fallback_protocol: "h2",
             http2_settings: { wait_for_handshake: false },
             grpc_rpcs: {}.freeze,
@@ -100,6 +70,37 @@ module HTTPX
         end
       end
 
+      module OptionsMethods
+        def option_grpc_service(value)
+          String(value)
+        end
+
+        def option_grpc_compression(value)
+          case value
+          when true, false
+            value
+          else
+            value.to_s
+          end
+        end
+
+        def option_grpc_rpcs(value)
+          Hash[value]
+        end
+
+        def option_grpc_deadline(value)
+          raise TypeError, ":grpc_deadline must be positive" unless value.positive?
+
+          value
+        end
+
+        def option_call_credentials(value)
+          raise TypeError, ":call_credentials must respond to #call" unless value.respond_to?(:call)
+
+          value
+        end
+      end
+
       module ResponseMethods
         attr_reader :trailing_metadata
 
@@ -140,9 +141,19 @@ module HTTPX
             deadline: @options.grpc_deadline,
           }.merge(opts)
 
-          with(grpc_rpcs: @options.grpc_rpcs.merge(
-            rpc_name.underscore => [rpc_name, input, output, rpc_opts]
-          ).freeze)
+          session_class = Class.new(self.class) do
+            class_eval(<<-OUT, __FILE__, __LINE__ + 1)
+              def #{rpc_name}(input, **opts)
+                rpc_execute("#{rpc_name}", input, **opts)
+              end
+            OUT
+          end
+
+          session_class.new(@options.merge(
+                              grpc_rpcs: @options.grpc_rpcs.merge(
+                                rpc_name.underscore => [rpc_name, input, output, rpc_opts]
+                              ).freeze
+                            ))
         end
 
         def build_stub(origin, service: nil, compression: false)
@@ -150,7 +161,32 @@ module HTTPX
 
           origin = URI.parse("#{scheme}://#{origin}")
 
-          with(origin: origin, grpc_service: service, grpc_compression: compression)
+          session = self
+
+          if service && service.respond_to?(:rpc_descs)
+            # it's a grpc generic service
+            service.rpc_descs.each do |rpc_name, rpc_desc|
+              rpc_opts = {
+                marshal_method: rpc_desc.marshal_method,
+                unmarshal_method: rpc_desc.unmarshal_method,
+              }
+
+              input = rpc_desc.input
+              input = input.type if input.respond_to?(:type)
+
+              output = rpc_desc.output
+              if output.respond_to?(:type)
+                rpc_opts[:stream] = true
+                output = output.type
+              end
+
+              session = session.rpc(rpc_name, input, output, **rpc_opts)
+            end
+
+            service = service.service_name
+          end
+
+          session.with(origin: origin, grpc_service: service, grpc_compression: compression)
         end
 
         def execute(rpc_method, input,
@@ -166,7 +202,7 @@ module HTTPX
         private
 
         def rpc_execute(rpc_name, input, **opts)
-          rpc_name, input_enc, output_enc, rpc_opts = @options.grpc_rpcs[rpc_name.to_s] || raise(Error, "#{rpc_name}: undefined service")
+          rpc_name, input_enc, output_enc, rpc_opts = @options.grpc_rpcs[rpc_name]
 
           exec_opts = rpc_opts.merge(opts)
 
@@ -180,7 +216,7 @@ module HTTPX
               end
             end
           else
-            input_enc.marshal(input)
+            input_enc.__send__(marshal_method, input)
           end
 
           call = execute(rpc_name, messages, **exec_opts)
@@ -230,16 +266,6 @@ module HTTPX
 
           build_request(:post, uri, headers: headers, body: body)
         end
-
-        def respond_to_missing?(meth, *, &blk)
-          @options.grpc_rpcs.key?(meth.to_s) || super
-        end
-
-        def method_missing(meth, *args, **kwargs, &blk)
-          return rpc_execute(meth, *args, **kwargs, &blk) if @options.grpc_rpcs.key?(meth.to_s)
-
-          super
-        end
       end
     end
     register_plugin :grpc, GRPC