restify 1.15.1 → 2.0.0

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
@@ -21,18 +16,16 @@ module Restify
         def parse(object, root: false)
           case object
             when Hash
-              data      = object.each_with_object({}, &method(:parse_data))
-              relations = object.each_with_object({}, &method(:parse_rels))
-
-              data = with_indifferent_access(data) if self.class.indifferent_access?
+              data      = object.each_with_object({}) {|each, obj| parse_data(each, obj) }
+              relations = object.each_with_object({}) {|each, obj| parse_rels(each, obj) }
 
               Resource.new context,
-                data: data,
+                data:,
                 response: root ? response : nil,
-                relations: relations
+                relations:
 
             when Array
-              object.map(&method(:parse))
+              object.map {|each| parse(each) }
             else
               object
           end
@@ -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/resource.rb

@@ -96,7 +96,7 @@ module Restify
     def inspect
       text = {
         '@data' => data,
-        '@relations' => @relations
+        '@relations' => @relations,
       }.map {|k, v| "#{k}=#{v.inspect}" }.join(' ')
 
       "#<#{self.class} #{text}>"

data/lib/restify/response.rb

@@ -89,7 +89,6 @@ module Restify
     #
     # @return [Array<Link>] Links.
     #
-    # rubocop:disable Metrics/MethodLength
     def links
       @links ||= begin
         if headers['LINK']
@@ -104,7 +103,6 @@ module Restify
         end
       end
     end
-    # rubocop:enable all
 
     # Return content type header from response headers.
     #

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,11 +2,11 @@
 
 module Restify
   module VERSION
-    MAJOR = 1
-    MINOR = 15
-    PATCH = 1
+    MAJOR = 2
+    MINOR = 0
+    PATCH = 0
     STAGE = nil
-    STRING = [MAJOR, MINOR, PATCH, STAGE].reject(&:nil?).join('.').freeze
+    STRING = [MAJOR, MINOR, PATCH, STAGE].compact.join('.').freeze
 
     def self.to_s
       STRING

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
-  let(:store) { double 'store' }
-  let(:cache) { described_class.new store }
+  subject(:cache) { described_class.new(store) }
 
-  subject { cache }
+  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

@@ -18,27 +18,30 @@ describe Restify::Context do
       end
 
       describe '#adapter' do
-        let(:kwargs) { {adapter: double('adapter')} }
         subject { super().options[:adapter] }
 
+        let(:kwargs) { {adapter: instance_double(Restify::Adapter::Base)} }
+
         it 'adapter is not serialized' do
           expect(subject).to equal nil
         end
       end
 
       describe '#cache' do
-        let(:kwargs) { {adapter: double('cache')} }
         subject { super().options[:cache] }
 
+        let(:kwargs) { {cache: Object.new} }
+
         it 'cache is not serialized' do
           expect(subject).to equal nil
         end
       end
 
       describe '#headers' do
-        let(:kwargs) { {headers: {'Accept' => 'application/json'}} }
         subject { super().options[:headers] }
 
+        let(:kwargs) { {headers: {'Accept' => 'application/json'}} }
+
         it 'all headers are serialized' do
           expect(subject).to eq('Accept' => 'application/json')
         end
@@ -46,20 +49,25 @@ describe Restify::Context do
     end
 
     context 'YAML' do
+      subject { load }
+
       let(:dump) { YAML.dump(context) }
-      let(:load) { YAML.load(dump) } # rubocop:disable Security/YAMLLoad
 
-      subject { load }
+      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
 
     context 'Marshall' do
+      subject { load }
+
       let(:dump) { Marshal.dump(context) }
       let(:load) { Marshal.load(dump) } # rubocop:disable Security/MarshalLoad
 
-      subject { load }
-
       include_examples 'serialization'
     end
   end

data/spec/restify/error_spec.rb

@@ -2,16 +2,13 @@
 
 require 'spec_helper'
 
-describe Restify::ResponseError do
-  let(:response) { double 'response' }
+describe Restify::ResponseError do # rubocop:disable RSpec/SpecFilePathFormat
+  let(:response) { instance_double(Restify::Response) }
   let(:message) { 'Error' }
   let(:uri) { 'http://localhost' }
 
   before do
-    allow(response).to receive(:uri).and_return(uri)
-    allow(response).to receive(:code).and_return(code)
-    allow(response).to receive(:message).and_return(message)
-    allow(response).to receive(:decoded_body).and_return({})
+    allow(response).to receive_messages(uri: uri, code: code, message: message, decoded_body: {})
   end
 
   describe '.from_code' do
@@ -19,52 +16,62 @@ describe Restify::ResponseError do
 
     context 'with 400 Bad Request' do
       let(:code) { 400 }
-      it { is_expected.to be_a ::Restify::BadRequest }
+
+      it { is_expected.to be_a Restify::BadRequest }
     end
 
     context 'with 401 Unauthorized' do
       let(:code) { 401 }
-      it { is_expected.to be_a ::Restify::Unauthorized }
+
+      it { is_expected.to be_a Restify::Unauthorized }
     end
 
     context 'with 404 Unauthorized' do
       let(:code) { 404 }
-      it { is_expected.to be_a ::Restify::NotFound }
+
+      it { is_expected.to be_a Restify::NotFound }
     end
 
     context 'with 406 Not Acceptable' do
       let(:code) { 406 }
-      it { is_expected.to be_a ::Restify::NotAcceptable }
+
+      it { is_expected.to be_a Restify::NotAcceptable }
     end
 
     context 'with 410 Gone' do
       let(:code) { 410 }
-      it { is_expected.to be_a ::Restify::Gone }
+
+      it { is_expected.to be_a Restify::Gone }
     end
 
     context 'with 422 Unprocessable Entity' do
       let(:code) { 422 }
-      it { is_expected.to be_a ::Restify::UnprocessableEntity }
+
+      it { is_expected.to be_a Restify::UnprocessableEntity }
     end
 
     context 'with 500 Internal Server Error' do
       let(:code) { 500 }
-      it { is_expected.to be_a ::Restify::InternalServerError }
+
+      it { is_expected.to be_a Restify::InternalServerError }
     end
 
     context 'with 502 Bad Gateway' do
       let(:code) { 502 }
-      it { is_expected.to be_a ::Restify::BadGateway }
+
+      it { is_expected.to be_a Restify::BadGateway }
     end
 
     context 'with 503 Service Unavailable' do
       let(:code) { 503 }
-      it { is_expected.to be_a ::Restify::ServiceUnavailable }
+
+      it { is_expected.to be_a Restify::ServiceUnavailable }
     end
 
     context 'with 504 Gateway Timeout' do
       let(:code) { 504 }
-      it { is_expected.to be_a ::Restify::GatewayTimeout }
+
+      it { is_expected.to be_a Restify::GatewayTimeout }
     end
   end
 end

data/spec/restify/features/head_requests_spec.rb

@@ -16,24 +16,26 @@ describe Restify do
   end
 
   describe 'HEAD requests' do
-    subject { Restify.new('http://localhost:9292/base').head(params).value! }
+    subject(:value) { Restify.new('http://localhost:9292/base').head(params:).value! }
+
     let(:params) { {} }
 
     it 'returns a resource with access to headers' do
-      expect(subject.response.headers).to include('CONTENT_LENGTH' => '333')
+      expect(value.response.headers).to include('CONTENT_LENGTH' => '333')
     end
 
     it 'parses Link headers into relations' do
-      expect(subject).to have_relation :neat
+      expect(value).to have_relation :neat
     end
 
     context 'with params' do
       let(:params) { {foo: 'bar'} }
 
       it 'adds them to the query string' do
-        subject
+        value
+
         expect(
-          request_stub.with(query: {foo: 'bar'})
+          request_stub.with(query: {foo: 'bar'}),
         ).to have_been_requested
       end
     end

data/spec/restify/features/request_bodies_spec.rb

@@ -13,25 +13,26 @@ describe Restify do
   end
 
   describe 'Request body' do
-    subject { Restify.new('http://localhost:9292/base').post(body, {}, {headers: headers}).value! }
+    subject(:value) { Restify.new('http://localhost:9292/base').post(body, headers:).value! }
+
     let(:headers) { {} }
 
     context 'with JSON-like data structures' do
       let(:body) { {a: 'b', c: 'd'} }
 
       it 'is serialized as JSON' do
-        subject
+        value
 
         expect(
-          request_stub.with(body: '{"a":"b","c":"d"}')
+          request_stub.with(body: '{"a":"b","c":"d"}'),
         ).to have_been_requested
       end
 
       it 'gets a JSON media type for free' do
-        subject
+        value
 
         expect(
-          request_stub.with(headers: {'Content-Type' => 'application/json'})
+          request_stub.with(headers: {'Content-Type' => 'application/json'}),
         ).to have_been_requested
       end
 
@@ -39,10 +40,10 @@ describe Restify do
         let(:headers) { {'Content-Type' => 'application/vnd.api+json'} }
 
         it 'respects the override' do
-          subject
+          value
 
           expect(
-            request_stub.with(headers: {'Content-Type' => 'application/vnd.api+json'})
+            request_stub.with(headers: {'Content-Type' => 'application/vnd.api+json'}),
           ).to have_been_requested
         end
       end
@@ -52,18 +53,18 @@ describe Restify do
       let(:body) { 'a=b&c=d' }
 
       it 'is sent as provided' do
-        subject
+        value
 
         expect(
-          request_stub.with(body: 'a=b&c=d')
+          request_stub.with(body: 'a=b&c=d'),
         ).to have_been_requested
       end
 
       it 'does not get a JSON media type' do
-        subject
+        value
 
         expect(
-          request_stub.with {|req| req.headers['Content-Type'] !~ /json/ }
+          request_stub.with {|req| !req.headers['Content-Type'].include?('json') },
         ).to have_been_requested
       end
 
@@ -71,10 +72,10 @@ describe Restify do
         let(:headers) { {'Content-Type' => 'application/text'} }
 
         it 'respects the override' do
-          subject
+          value
 
           expect(
-            request_stub.with(headers: {'Content-Type' => 'application/text'})
+            request_stub.with(headers: {'Content-Type' => 'application/text'}),
           ).to have_been_requested
         end
       end

data/spec/restify/features/request_errors_spec.rb

@@ -2,13 +2,13 @@
 
 require 'spec_helper'
 
-describe Restify, adapter: ::Restify::Adapter::Typhoeus do
+describe Restify, adapter: 'Restify::Adapter::Typhoeus' do
   before do
     stub_request(:get, 'http://stubserver/base').to_timeout
   end
 
   describe 'Timeout' do
-    subject(:request) { Restify.new('http://localhost:9292/base').get({}, timeout: 0.1).value! }
+    subject(:request) { Restify.new('http://localhost:9292/base').get(timeout: 0.1).value! }
 
     it 'throws a network error' do
       expect { request }.to raise_error Restify::NetworkError do |error|