restify 1.15.2 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c29c95a9b1c0b18f2a73b51c99da7cdddf163e1cee33c43272810f5557b1375b
-  data.tar.gz: 95f956684154058cc6f25b7d4ffebde6706864b00c1369e91c8f8b5fcc50f0d9
+  metadata.gz: 85964ce70270ead0fcc3271b733611bcb97f8415e03a91b46cb402032a4c68f5
+  data.tar.gz: 0c99e59283131de272b9a2a1ad23589395bb89e5b8753e330f305e7ec1483685
 SHA512:
-  metadata.gz: f420cc4d0c4ebbdade1bc1a780c24218b5eea707bd8e420c113d155d58067936464dc3d4807717de8f515ed586784c9f13476b46c66f68c8d1181501937db3a2
-  data.tar.gz: 71da11cdf50d25abc968af02c6157c63f1aa5703c88f7ae28c3394aa028d9f038013d220283510532f7b540dffc69d0abad5fe4952c4e27df4910a4009475ae5
+  metadata.gz: 58bf934808c55172f28ec0673f543531c935b68e8e1f8fcf62435b49dfd7ab2e13522ef6c8b675fbfaf234be7ebfac4fdbfe05d57da4e97288b3876000a2487f
+  data.tar.gz: 4617aa58aa9ba400e1f28a0e5a854c5b56a560abb818432211958295e695feab6fe4bfeb0b5bd6418b231260db778804f4cf5309a34f8d1db9cb501d5f48fe6b

data/CHANGELOG.md

@@ -5,8 +5,8 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
 and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
 
-
 ## Unreleased
+
 ---
 
 ### New
@@ -17,6 +17,30 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
 
 ### Breaks
 
+## 2.0.0 - (2025-02-14)
+
+---
+
+### New
+
+- Support for Ruby 3.4
+- Experimental support for OpenTelemetry tracing
+
+### Changes
+
+- Strict keyword handling for request methods
+
+  All request methods take parameters and headers as explicit keyword arguments, not as secondary arguments anymore. Change e.g. `get({}, {headers: ...})` into `get(headers: ...)`, and `head(params)` to `head(params:)`.
+
+  `#post`, `#put`, and `#patch` still take an optional first positional data/body argument. Change `post(body, {}, {headers: ...})` to `post(body, headers: ...)`.
+
+  `#get`, `#head`, and `#delete` accept a hash as the first positional argument, which is merged with `params:`. Therefore, passing parameters as data works too: `get({id: 1})`.
+
+### Breaks
+
+- Remove indifferent access methods (Hashie) from responses
+- Removed `em` and `em-pooled` adapters
+- Require Ruby 3.1+
 
 ## 1.15.2 - (2021-12-23)
 
@@ -26,7 +50,6 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
 
 - ActiveSupport v7.0 issues with cache module
 
-
 ## 1.15.1 - (2021-07-15)
 
 ---

data/README.md

@@ -1,7 +1,8 @@
 # Restify
 
-[![Build Status](https://travis-ci.org/jgraichen/restify.svg?branch=master)](https://travis-ci.org/jgraichen/restify)
-[![Code Quality](https://codebeat.co/badges/18ffe6b7-8239-493a-b5b6-be329b9f275d)](https://codebeat.co/projects/github-com-jgraichen-restify-master)
+[![Gem Version](https://img.shields.io/gem/v/restify?logo=ruby)](https://rubygems.org/gems/restify)
+[![GitHub Actions Workflow Status](https://img.shields.io/github/actions/workflow/status/jgraichen/restify/test.yml?logo=github)](https://github.com/jgraichen/restify/actions)
+[![Code Quality](https://codebeat.co/badges/368f8033-bd76-48bc-9777-85f1d4befa94)](https://codebeat.co/projects/github-com-jgraichen-restify-main)
 
 Restify is an hypermedia REST client that does parallel, concurrent and keep-alive requests by default.
 
@@ -27,16 +28,19 @@ Links are extracted from
 * HTTP Link header
 * Github-style relations in payloads
 
-### Planned features
+## Installation
 
-* HTTP cache
-* API versions via header
-* Content-Type and Language negotiation
-* Processors for JSON-HAL, etc.
+Add it to your Gemfile:
 
-## Installation
+```ruby
+gem 'restify', '~> 2.0'
+```
 
-Add it to your Gemfile or install it manually: `$ gem install restify`
+Or install it manually:
+
+```console
+gem install restify
+```
 
 ## Usage
 
@@ -51,7 +55,7 @@ client = Restify.new('https://api.github.com').get.value
 # ...
 ```
 
-We are essentially requesting `'http://api.github.com'` via HTTP `get`. `get` is returning an `Promise`, similar to Java's `Future`. The `value` call resolves the returned `Promise` by blocking the thread until the resource is actually there. `value!` will additionally raise errors instead of returning `nil`. You can chain handlers using the `then` method. This allows you to be build a dependency chain that will be executed when the last promise is needed.
+We are essentially requesting `'http://api.github.com'` via HTTP `get`. `get` is returning a `Promise`, similar to Java's `Future`. The `value` call resolves the returned `Promise` by blocking the thread until the resource is actually there. `value!` will additionally raise errors instead of returning `nil`. You can chain handlers using the `then` method. This allows you to be build a dependency chain that will be executed when the last promise is needed.
 
 As we can see GitHub returns us a field `repository_url` with a URI template. Restify automatically scans for `*_url` fields in the JSON response and exposes these as relations. It additionally scans the HTTP Header field `Link` for relations like pagination.
 
@@ -65,33 +69,21 @@ repositories = client.rel(:repository)
 This gets us the relation named `repository` that we can request now. The usual HTTP methods are available on a relation:
 
 ```ruby
-    def get(params = {})
-      request :get, nil, params
-    end
-
-    def delete(params = {})
-      request :delete, nil, params
-    end
-
-    def post(data = {}, params = {})
-      request :post, data, params
-    end
-
-    def put(data = {}, params = {})
-      request :put, data, params
-    end
+def get(params, params:, headers:, **)
+def head(params, params:, headers:, **)
+def delete(params, params:, headers:, **)
 
-    def patch(data = {}, params = {})
-      request :patch, data, params
-    end
+def put(data = nil, params:, headers:, **)
+def post(data = nil, params:, headers:, **)
+def patch(data = nil, params:, headers:, **)
 ```
 
-URL templates can define some parameters such as `{owner}` or `{repo}`. They will be expanded from the `params` given to the HTTP method method.
+URL templates can define some parameters such as `{owner}` or `{repo}`. They will be expanded from the `params` given to the HTTP method.
 
 Now send a GET request with some parameters to request a specific repository:
 
 ```ruby
-repo = repositories.get(owner: 'jgraichen', repo: 'restify').value
+repo = repositories.get({owner: 'jgraichen', repo: 'restify'}).value
 ```
 
 Now fetch a list of commits for this repo and get this first one:
@@ -121,7 +113,7 @@ See commented example in main spec [`spec/restify_spec.rb`](https://github.com/j
 
 ## License
 
-Copyright (C) 2014-2018 Jan Graichen
+Copyright (C) 2014-2025 Jan Graichen
 
 This program is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
 

data/lib/restify/adapter/base.rb

@@ -1,8 +1,12 @@
 # frozen_string_literal: true
 
+require 'restify/adapter/telemetry'
+
 module Restify
   module Adapter
     class Base
+      prepend Telemetry
+
       def call(request)
         Promise.create do |writer|
           call_native request, writer

data/lib/restify/adapter/telemetry.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require 'opentelemetry'
+require 'opentelemetry/common'
+
+module Restify
+  module Adapter
+    module Telemetry
+      def call(request)
+        method = request.method.to_s.upcase
+        uri = URI.parse(request.uri)
+        name = "#{method} #{uri.scheme}://#{uri.host}:#{uri.port}"
+
+        attributes = {
+          'http.request.method' => method,
+          'server.address' => uri.host,
+          'server.port' => uri.port,
+          'url.full' => uri.to_s,
+          'url.scheme' => uri.scheme,
+        }
+
+        span = tracer.start_span(name, attributes:, kind: :client)
+        OpenTelemetry::Trace.with_span(span) do
+          OpenTelemetry.propagation.inject(request.headers)
+
+          super.tap do |x|
+            x.add_observer do |_, response, err|
+              if response
+                span.set_attribute('http.response.status_code', response&.code)
+                span.status = OpenTelemetry::Trace::Status.error unless (100..399).cover?(response&.code)
+              end
+
+              span.status = OpenTelemetry::Trace::Status.error(err) if err
+
+              span.finish
+            end
+          end
+        end
+      end
+
+      protected
+
+      def tracer
+        Telemetry.tracer
+      end
+
+      class << self
+        def tracer
+          @tracer ||= OpenTelemetry.tracer_provider.tracer('restify', Restify::VERSION.to_s)
+        end
+      end
+    end
+  end
+end

data/lib/restify/adapter/typhoeus.rb

@@ -2,7 +2,7 @@
 
 require 'typhoeus'
 
-::Ethon.logger = ::Logging.logger[Ethon]
+Ethon.logger = Logging.logger[Ethon]
 
 module Restify
   module Adapter
@@ -23,8 +23,26 @@ module Restify
         tcp_keepintvl: 5,
       }.freeze
 
+      # Patch to store easy handles in the queue, instead of requests.
+      # This improves compatibility with OpenTelemetry instrumentation
+      # for Ethon, that needs the request handle to be constructed in
+      # the current threading context, not the background thread were
+      # Typhoeus is running.
+      module EasyOverride
+        def queue(request)
+          request.hydra = self
+          queued_requests << ::Typhoeus::EasyFactory.new(request, self).get
+        end
+
+        def add(handle)
+          multi.add(handle)
+        end
+      end
+
       def initialize(sync: false, options: {}, **kwargs)
-        @hydra   = ::Typhoeus::Hydra.new(**kwargs)
+        @hydra = ::Typhoeus::Hydra.new(**kwargs)
+        @hydra.extend(EasyOverride)
+
         @mutex   = Mutex.new
         @options = DEFAULT_OPTIONS.merge(options)
         @queue   = Queue.new
@@ -102,7 +120,7 @@ module Restify
       def convert_headers(headers)
         return {} unless headers.respond_to?(:each_pair)
 
-        headers.each_pair.each_with_object({}) do |header, memo|
+        headers.each_pair.with_object({}) do |header, memo|
           memo[header[0].upcase.tr('-', '_')] = header[1]
         end
       end

data/lib/restify/context.rb

@@ -51,9 +51,9 @@ module Restify
       request = Request.new(
         headers: default_headers.merge(headers),
         **kwargs,
-        method: method,
+        method:,
         uri: join(uri),
-        data: data,
+        data:,
       )
 
       ret = cache.call(request) {|req| adapter.call(req) }
@@ -80,7 +80,7 @@ module Restify
     end
 
     def marshal_load(dump)
-      initialize dump.delete(:uri), \
+      initialize dump.delete(:uri),
         headers: dump.fetch(:headers)
     end
 

data/lib/restify/error.rb

@@ -55,8 +55,8 @@ module Restify
 
     def initialize(response)
       @response = response
-      super "#{response.message} (#{response.code}) for `#{response.uri}':\n" \
-            "  #{errors.inspect}"
+      super("#{response.message} (#{response.code}) for `#{response.uri}':\n  " \
+            "#{errors.inspect}")
     end
 
     # Return response status.

data/lib/restify/link.rb

@@ -25,10 +25,10 @@ module Restify
     end
 
     class << self
-      REGEXP_URI = /<[^>]*>\s*/.freeze
-      REGEXP_PAR = /;\s*\w+\s*=\s*/i.freeze
-      REGEXP_QUT = /"[^"]*"\s*/.freeze
-      REGEXP_ARG = /\w+\s*/i.freeze
+      REGEXP_URI = /<[^>]*>\s*/
+      REGEXP_PAR = /;\s*\w+\s*=\s*/i
+      REGEXP_QUT = /"[^"]*"\s*/
+      REGEXP_ARG = /\w+\s*/i
 
       def parse(string)
         scanner = StringScanner.new(string.strip)

data/lib/restify/processors/base/parsing.rb

@@ -9,11 +9,6 @@ module Restify
       # Parses generic data structures into resources
       #
       module Parsing
-        def self.included(base)
-          base.extend ClassMethods
-          base.indifferent_access = true
-        end
-
         def load
           parse deserialized_body, root: true
         end
@@ -24,12 +19,10 @@ module Restify
               data      = object.each_with_object({}) {|each, obj| parse_data(each, obj) }
               relations = object.each_with_object({}) {|each, obj| parse_rels(each, obj) }
 
-              data = with_indifferent_access(data) if self.class.indifferent_access?
-
               Resource.new context,
-                data: data,
+                data:,
                 response: root ? response : nil,
-                relations: relations
+                relations:
 
             when Array
               object.map {|each| parse(each) }
@@ -58,18 +51,6 @@ module Restify
 
           relations[name] = pair[1].to_s
         end
-
-        def with_indifferent_access(data)
-          Hashie::Mash.new data
-        end
-
-        module ClassMethods
-          def indifferent_access?
-            @indifferent_access
-          end
-
-          attr_writer :indifferent_access
-        end
       end
     end
   end

data/lib/restify/processors/base.rb

@@ -16,7 +16,7 @@ module Restify
         @resource ||= begin
           resource = load
 
-          resource = Resource.new context, response: response, data: resource unless resource.is_a? Restify::Resource
+          resource = Resource.new context, response:, data: resource unless resource.is_a? Restify::Resource
 
           resource._restify_response = response
           merge_relations! resource._restify_relations

data/lib/restify/promise.rb

@@ -25,8 +25,8 @@ module Restify
       self
     end
 
-    def then(&block)
-      Promise.new([self], &block)
+    def then(&)
+      Promise.new([self], &)
     end
 
     def execute(timeout = nil)

data/lib/restify/registry.rb

@@ -7,7 +7,7 @@ module Restify
     end
 
     def store(name, uri, **opts)
-      @registry[name] = Context.new uri, **opts
+      @registry[name] = Context.new(uri, **opts)
     end
 
     def fetch(name)

data/lib/restify/relation.rb

@@ -19,32 +19,35 @@ module Restify
       @template = Addressable::Template.new template
     end
 
-    def request(method, data, params, opts = {})
-      context.request method, expand(params), **opts, data: data
+    def request(method:, params: {}, **opts)
+      context.request(method, expand(params), **opts)
     end
 
-    def get(params = {}, opts = {})
-      request :get, nil, params, opts
+    def get(data = {}, params: {}, **opts)
+      request(**opts, method: :get, params: data.merge(params))
     end
 
-    def head(params = {}, opts = {})
-      request :head, nil, params, opts
+    def head(data = {}, params: {}, **opts)
+      request(**opts, method: :head, params: data.merge(params))
     end
 
-    def delete(params = {}, opts = {})
-      request :delete, nil, params, opts
+    def delete(data = {}, params: {}, **opts)
+      request(**opts, method: :delete, params: data.merge(params))
     end
 
-    def post(data = {}, params = {}, opts = {})
-      request :post, data, params, opts
+    def post(data = nil, **opts)
+      opts[:data] = data unless opts.key?(:data)
+      request(**opts, method: :post)
     end
 
-    def put(data = {}, params = {}, opts = {})
-      request :put, data, params, opts
+    def put(data = nil, **opts)
+      opts[:data] = data unless opts.key?(:data)
+      request(**opts, method: :put)
     end
 
-    def patch(data = {}, params = {}, opts = {})
-      request :patch, data, params, opts
+    def patch(data = nil, **opts)
+      opts[:data] = data unless opts.key?(:data)
+      request(**opts, method: :patch)
     end
 
     def ==(other)
@@ -72,14 +75,39 @@ module Restify
     private
 
     def convert(params)
-      params.each_pair.each_with_object({}) do |param, hash|
+      params.each_pair.with_object({}) do |param, hash|
         hash[param[0]] = convert_param param[1]
       end
     end
 
-    def convert_param(value)
-      return value.to_param.to_s if value.respond_to?(:to_param)
+    def convert_param(value, nesting: true)
+      # Convert parameters into values acceptable in a
+      # Addressable::Template, with some support for #to_param, but not
+      # for basic types.
+      if value == nil || # rubocop:disable Style/NilComparison
+         value.is_a?(Numeric) ||
+         value.is_a?(Symbol) ||
+         value.is_a?(Hash) ||
+         value == true ||
+         value == false ||
+         value.respond_to?(:to_str)
+        return value
+      end
+
+      # Handle array-link things first to *not* call #to_params on them,
+      # as that will concatenation any Array to "a/b/c". Instead, we
+      # want to check one level of basic types only.
+      if value.respond_to?(:to_ary)
+        return nesting ? value.to_ary.map {|val| convert_param(val, nesting: false) } : value
+      end
+
+      # Handle Rails' #to_param for non-basic types
+      if value.respond_to?(:to_param)
+        return value.to_param
+      end
 
+      # Otherwise, pass raw value to Addressable::Template and let it
+      # explode.
       value
     end
 

data/lib/restify/request.rb

@@ -29,12 +29,12 @@ module Restify
     #
     attr_reader :timeout
 
-    def initialize(opts = {})
-      @method  = opts.fetch(:method, :get).downcase
-      @uri     = opts.fetch(:uri) { raise ArgumentError.new ':uri required.' }
-      @data    = opts.fetch(:data, nil)
-      @timeout = opts.fetch(:timeout, 300)
-      @headers = opts.fetch(:headers, {})
+    def initialize(uri:, method: :get, data: nil, timeout: 300, headers: {})
+      @uri     = uri
+      @method  = method.to_s.downcase
+      @data    = data
+      @timeout = timeout
+      @headers = headers
 
       @headers['Content-Type'] ||= 'application/json' if json?
     end

data/lib/restify/timeout.rb

@@ -71,9 +71,9 @@ module Restify
         @target = target
 
         if @target
-          super "Operation on #{@target} timed out"
+          super("Operation on #{@target} timed out")
         else
-          super 'Operation timed out'
+          super('Operation timed out')
         end
       end
     end

data/lib/restify/version.rb

@@ -2,9 +2,9 @@
 
 module Restify
   module VERSION
-    MAJOR = 1
-    MINOR = 15
-    PATCH = 2
+    MAJOR = 2
+    MINOR = 0
+    PATCH = 0
     STAGE = nil
     STRING = [MAJOR, MINOR, PATCH, STAGE].compact.join('.').freeze
 

data/lib/restify.rb

@@ -4,7 +4,6 @@ require 'forwardable'
 
 require 'restify/version'
 
-require 'hashie'
 require 'concurrent'
 require 'addressable/uri'
 require 'addressable/template'

data/spec/restify/cache_spec.rb

@@ -1,36 +1,40 @@
 # frozen_string_literal: true
 
 require 'spec_helper'
+require 'active_support'
+require 'active_support/cache'
 
 describe Restify::Cache do
-  subject { cache }
+  subject(:cache) { described_class.new(store) }
 
-  let(:store) { double 'store' }
-  let(:cache) { described_class.new store }
+  let(:store) { instance_double(ActiveSupport::Cache::Store) }
 
   describe '#call' do
-    let(:request) { double 'request' }
-    let(:promise0) { double 'promise0' }
-    let(:promise1) { double 'promise1' }
-    let(:response) { double 'response' }
+    let(:request) { instance_double(Restify::Request) }
+    let(:promise0) { instance_double(Restify::Promise, 'promise0') } # rubocop:disable RSpec/IndexedLet
+    let(:promise1) { instance_double(Restify::Promise, 'promise1') } # rubocop:disable RSpec/IndexedLet
+    let(:response) { instance_double(Restify::Response) }
 
     it 'yields with promises' do
-      expect(promise0).to receive(:then).and_yield(response).and_return(promise1)
+      allow(promise0).to receive(:then).and_yield(response).and_return(promise1)
 
-      expect(subject.call(request) { promise0 }).to eq promise1
+      expect(cache.call(request) { promise0 }).to eq promise1
     end
 
     it 'caches new responses' do
-      expect(promise0).to receive(:then).and_yield(response)
+      allow(promise0).to receive(:then).and_yield(response)
+
+      # TODO: Do not stub inside tested object
       expect(cache).to receive(:cache).with(response)
 
-      subject.call(request) { promise0 }
+      cache.call(request) { promise0 }
     end
 
     it 'returns with match' do
+      # TODO: Do not stub inside tested object
       expect(cache).to receive(:match).with(request).and_return(response)
 
-      expect(subject.call(request)).to eq response
+      expect(cache.call(request)).to eq response
     end
   end
 end

data/spec/restify/context_spec.rb

@@ -20,7 +20,7 @@ describe Restify::Context do
       describe '#adapter' do
         subject { super().options[:adapter] }
 
-        let(:kwargs) { {adapter: double('adapter')} }
+        let(:kwargs) { {adapter: instance_double(Restify::Adapter::Base)} }
 
         it 'adapter is not serialized' do
           expect(subject).to equal nil
@@ -30,7 +30,7 @@ describe Restify::Context do
       describe '#cache' do
         subject { super().options[:cache] }
 
-        let(:kwargs) { {adapter: double('cache')} }
+        let(:kwargs) { {cache: Object.new} }
 
         it 'cache is not serialized' do
           expect(subject).to equal nil
@@ -52,7 +52,12 @@ describe Restify::Context do
       subject { load }
 
       let(:dump) { YAML.dump(context) }
-      let(:load) { YAML.load(dump) } # rubocop:disable Security/YAMLLoad
+
+      if RUBY_VERSION >= '3.1'
+        let(:load) { YAML.safe_load(dump, permitted_classes: [Restify::Context, Symbol]) }
+      else
+        let(:load) { YAML.load(dump) }
+      end
 
       include_examples 'serialization'
     end